create or replace procedure ins_cat(v_id int,v_pid int,v_name varchar2) as
begin
 insert into categories values(v_id,v_pid,v_name);
end ins_cat;

*/

--delete from categories;
/*
begin
ins_cat(1,null,'category1');
ins_cat(2,null,'category2');
ins_cat(3,1,'category3');
ins_cat(4,1,'category4');
ins_cat(5,2,'category5');
ins_cat(6,2,'category6');
ins_cat(7,4,'category7');
ins_cat(8,4,'category8');
ins_cat(9,5,'category9');
end;
*/
select * from categories;

--start with .. connect by 递归遍历无限级类别
select * from categories start with id=2
 connect by prior id=pid;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;

/**
 *
 * @author semovy 测试向oracle 读,写文件Blob 读,写大文本Clob
 */
public class OracleBlobTest {

 private String driver = "oracle.jdbc.driver.OracleDriver";

 private String url = "jdbc:oracle:thin:@localhost:1521:teckotooling";

 private String user = "scott";

 private String pwd = "tiger";

 public OracleBlobTest() {
 }

 public static void main(String[] args) {
  OracleBlobTest obt = new OracleBlobTest();
  obt.writeBlob();
  obt.readBlob();
  obt.writeClob();
  obt.readClob();
 }

 /**
  * 读二进制文件
  *
  */
 private void readBlob() {
  Connection conn = null;
  try {
   conn = getConnection();
   Statement stmt = conn.createStatement();
   ResultSet rs = stmt.executeQuery("select * from test where id=1");
   byte[] buffer = new byte[1024];
   OutputStream out = new FileOutputStream("d:/360安全卫士定1.exe");
   int tempLen = 0;
   int amount = 0;
   if (rs.next()) {
    Blob blob = rs.getBlob("BINARYCONTENT");
    InputStream in = blob.getBinaryStream();
    while ((tempLen = in.read(buffer)) != -1) {
     out.write(buffer, 0, tempLen);
     amount += tempLen;
     System.out.println("已经读出并写:" + amount + " 字节");
    }
    System.out.println("已经读出并写:完成");
    out.flush();
    out.close();
    in.close();
    rs.close();
    stmt.close();
   }
  } catch (ClassNotFoundException e) {
   System.out.println(e.getLocalizedMessage());
  } catch (SQLException e) {
   System.out.println(e.getLocalizedMessage());
  } catch (IOException e) {
   System.out.println(e.getLocalizedMessage());
  } finally {
   try {
    if (conn != null)
     conn.close();
   } catch (SQLException e) {
    System.out.println(e.getLocalizedMessage());
   }
  }
 }

 /**
  * 写二进制文件
  *
  */
 private void writeBlob() {
  Connection conn = null;
  try {
   conn = getConnection();
   conn.setAutoCommit(false);
   String sql = null;
   Statement stmt = conn.createStatement();
   sql = "delete from test where id=1";
   stmt.executeUpdate(sql);
   sql = "insert into test(1,BINARYCONTENT,CLOBCONTENT) values(1,empty_blob(),empty_clob())";
   stmt.executeUpdate(sql);
   ResultSet rs = stmt.executeQuery("select * from test where id=1");
   if (rs.next()) {
    Blob blob = rs.getBlob("BINARYCONTENT");
    OutputStream out = ((oracle.sql.BLOB) blob).setBinaryStream(0);// 从0开始,否则写出的文件有差错
    int bufferSize = ((oracle.sql.BLOB) blob).getBufferSize();
    System.out.println("bufferSize :" + bufferSize);
    BufferedInputStream in = new BufferedInputStream(
      new FileInputStream("d:/360安全卫士定.exe"), bufferSize);
    byte[] b = new byte[bufferSize];
    int count = in.read(b, 0, bufferSize);
    int amount = 0;
    while (count != -1) {
     out.write(b, 0, count);
     amount += count;
     System.out.println("处理了 " + amount + " 字节");
     count = in.read(b, 0, bufferSize);
     System.out.println("处理了 " + amount + " 字节,成功");
    }
    out.close();
    out = null;
    in.close();
    conn.commit();
   }

  } catch (ClassNotFoundException e) {
   System.out.println(e.getLocalizedMessage());
  } catch (SQLException e) {
   try {
    conn.rollback();
   } catch (SQLException e1) {
    System.out.println(e1.getLocalizedMessage());
   }
   System.out.println(e.getLocalizedMessage());
  } catch (IOException e) {
   System.out.println(e.getLocalizedMessage());
  } finally {
   try {
    if (conn != null)
     conn.close();
   } catch (SQLException e) {
    System.out.println(e.getLocalizedMessage());
   }
  }
 }

 /**
  * 读大文本
  *
  */
 private void readClob() {
  Connection conn = null;
  try {
   conn = getConnection();
   Statement stmt = conn.createStatement();
   ResultSet rs = stmt.executeQuery("select * from test where id=2");
   String tempStr = null;
   if (rs.next()) {
    Clob clob = rs.getClob("CLOBCONTENT");
    if (clob != null) {
     Reader in = clob.getCharacterStream();
     BufferedReader br = new BufferedReader(in);
     System.out.println("开始读....");
     while ((tempStr = br.readLine()) != null) {
      System.out.println(tempStr);
     }
     System.out.println("读完成....");
     in.close();
    }
    rs.close();
    stmt.close();
   }
  } catch (ClassNotFoundException e) {
   System.out.println(e.getLocalizedMessage());
  } catch (SQLException e) {
   System.out.println(e.getLocalizedMessage());
  } catch (IOException e) {
   System.out.println(e.getLocalizedMessage());
  } finally {
   try {
    if (conn != null)
     conn.close();
   } catch (SQLException e) {
    System.out.println(e.getLocalizedMessage());
   }
  }
 }

 /**
  * 写大文本
  *
  */
 private void writeClob() {
  Connection conn = null;
  try {
   conn = getConnection();
   conn.setAutoCommit(false);
   String sql = null;
   Statement stmt = conn.createStatement();
   sql = "delete from test where id=2";
   stmt.executeUpdate(sql);
   sql = "insert into test values(2,empty_blob(),empty_clob())";
   stmt.executeUpdate(sql);
   ResultSet rs = stmt.executeQuery("select * from test where id=2");
   if (rs.next()) {
    Clob clob = rs.getClob("CLOBCONTENT");
    PrintWriter out = new PrintWriter(new BufferedWriter(
      ((oracle.sql.CLOB) clob).setCharacterStream(0)));
    BufferedReader in = new BufferedReader(new InputStreamReader(
      new FileInputStream(
        "d:/在北大校园BBS引起轰动的一篇文章请热爱祖国的人转发！！！！.mht")));
    String str = null;
    System.out.println("开始写...");
    while ((str = in.readLine()) != null) {
     out.println(str);
     System.out.println(str);
    }
    in.close();
    out.close();
    rs.close();
    conn.commit();
   }

  } catch (ClassNotFoundException e) {
   System.out.println(e.getLocalizedMessage());
  } catch (SQLException e) {
   try {
    conn.rollback();
   } catch (SQLException e1) {
    System.out.println(e1.getLocalizedMessage());
   }
   System.out.println(e.getLocalizedMessage());
  } catch (IOException e) {
   System.out.println(e.getLocalizedMessage());
  } finally {
   try {
    if (conn != null)
     conn.close();
   } catch (SQLException e) {
    System.out.println(e.getLocalizedMessage());
   }
  }
 }

 private Connection getConnection() throws ClassNotFoundException,
   SQLException {
  Class.forName(driver);
  return DriverManager.getConnection(url, user, pwd);
 }

 /**
  *
  * @param rs
  * @throws SQLException
  */
 private void displayResultSet(ResultSet rs) throws SQLException {
  ResultSetMetaData rsmd = rs.getMetaData();
  int colnum = rsmd.getColumnCount();
  while (rs.next()) {
   for (int i = 0; i < colnum; i++) {
    if (i == colnum - 1)
     System.out.print(rsmd.getColumnLabel(i + 1) + ": "
       + rs.getObject(i + 1));
    else
     System.out.print(rsmd.getColumnLabel(i + 1) + ": "
       + rs.getObject(i + 1) + " , ");
   }
   System.out.println();
  }
 }
}

1.创建表空间：

create tablespace tablespace_name datafile 'filepath' size filesize autoextend on next autosize maxsize filemaxsize [unlimited]

eg:

create tablespace sales datafile 'c:\1.txt' size 10m autoextend on next 1m maxsize 100m

2.为表空间增加数据文件：

alter tablespace tablespace_name add datafile 'filepath' size filesize autoextend on next autosize maxsize filemaxsize[unlimited]

eg:

alter tablespace sales datafile 'c:\2.txt' size 10m autoextend on next 1m maxsize unlimited

3.调整表空间：

alter database datafile 'filepath' resize filesize--重置表空间的大小

eg:

alter database datafile 'c:\2.txt' resize 10m

4.关闭表空间的自动扩展属性：

alter database datafile 'filepath' autoextend off

eg:

alter database datafile 'c:\2.txt' autoextend off

5.打开表空间的自动扩展属性：

alter database datafile 'filepath' autoextend on

eg:

alter database datafile 'c:\2.txt' autoextend on

6.使表空间脱机：

alter tablespace tablespace_name offline

7.使表空间联机：

alter tablespace tablespace_name online

8.设置表空间为只读：

alter tablespace tablespace_name read only

9.设置表空间为读写：

alter tablespace tablespace_name read write

11.删除表空间：

drop tablespace tablespace_name

12.删除表空间的同时，删除数据文件

drop tablespace tablespace_name including contents and datefiles

13.查看每个表空间占用空间的大小：

select tablespace_name,sum(bytes)/1024/1024 from dba_segments group by tablespace_name

10.移动表空间数据文件步骤：

a.使表空间脱机：alter tablespace tablespace_name offline

b.物理移动数据文件到目的地（可以是表空间的部分数据文件或者是修改数据文件的名称）

c.逻辑移动：alter tablespace tablespace_name rename datafile '源文件地址'to '目的文件地址'--注意可以将多个源文件转移到同一个目的文件地址（多个源文件地址用逗号分隔）

d.将表空间联机：alter tablespace tablespace_name online

11.查询表空间的信息：

select tablespace_name,bytes/1024/1024  file_size_mb,file_name from DBA_DATE_FILES--注意书籍库中的实体都是以大写表示

12.当数据文件被删除的时候，如果对该数据文件操作的时候，oracle会报不能找到该数据文件的错误。如何处理。

（1）shutdown—关闭oracle实例

（2）startup  --开启oracle实例并打开数据库

（3）alter database datafile ‘datafile_name’ offline drop;

（4）alter database open

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

正规表达式是符号和元素的集合，这些集合可以使用户匹配特定的文本模式。正规表达式采用元符号的组合来定义各种匹配和搜索标准。在正规表达式中，匹配是大小写敏感的。

元符号                  描述                           示例

*                 匹配0个或多个任意的字符         bd* 匹配bdq，bdabc

？                匹配一个任意的字符               B?d匹配 BDd,Bld

^                 表示字符串的开始                 ^abc与abced，abcfr可acdv

$                 表示字符串的末尾                 bas$ 以bas为结尾的所有字符串

x|y                匹配x或y                       windo|door表示windo或者dr

[]                 匹配[]中的任意一个字符           ba[a-b]匹配baa 或bab

{m}               可以匹配m次                    m[0-9]{3}匹配m7，m12，m123                    

{m,n}             至少m次最多n次                 

\n                表示前一个表达式可以重复N 次    [aeiou]\2 匹配aatldf 但abldf

[：：]             指定一个字符类，匹配该类中的任意一个字符

使用正规表达式：

函数                                         描述

Regexp_like()      类似于like运算符，可以使用正规表达式执行模式匹配操作

Regexp_instr()     instr运算的扩张，可以用来搜索匹配正规表达式模式的输入字符串

Regexp_replace()   replace的扩展，用户搜索符合正规表达式模式的输入字符串，并用指定的字符代替这些字符串

Regexp_substr()    substr函数的扩展，用户搜索符合正规表达式模式的输入字符串，输出是这些搜索到的字符串

说明：

一：Regexp_like(search_string,pattern [,match_option]);

(1):search_string是搜索值

(2):parrern 是使用得正规表达式且其长度限制在512字节内

(3)match_option:是一个文本串，可以使用户设置该函数的匹配行为

Match_option参数表：

值                   描述

C                 匹配时，大小写敏感，是默认设置

I                  匹配时，大小写不敏感

N                 允许使用圆点（。）匹配任何新增的字符

M                 

Eg：

Select author_id,last_name from author where regexp_liek(last_name,’e$’);--搜索以e结尾的作者姓名

二：regexp_instr(search_string,pattern,[,position [,occurrence [,return_option [,match_option ]]]]);

(1) :search_string是搜索值

(2):parrern 是使用得正规表达式且其长度限制在512字节内

(3)position 是一个表示搜索开始位置的正整数，默认为一。

(4)occurrence定义了搜索模式的发生次数，默认为一，

(5)return_optionshi 是一个数字，表示该函数应该返回的值。该数字可以是0（表示开始匹配的位置）也可以是非0（表示匹配的结束位置）

(6)match_option 是设置该函数匹配行为的参数

Eg：

Select regexp_instr(‘orcale database 10g’,’a’,1,2) from dual;

三：

regexp_replace((search_string,pattern,[,position[,occurrence[,return_option [,match_option ]]]]);

(1) :search_string是搜索值

(2):parrern 是使用得正规表达式且其长度限制在512字节内

(3)position 是一个表示搜索开始位置的正整数，默认为一。

(4)occurrence定义了搜索模式的发生次数，默认为一，

(5)return_optionshi 是一个数字，表示该函数应该返回的值。该数字可以是0（表示开始匹配的位置）也可以是非0（表示匹配的结束位置）

(6)match_option 是设置该函数匹配行为的参数

)

Select last_name,regexp_replace(last_name,’e’,’E’) from duthors where author_id<3

四：

Regexp_substr(seach_string,pattern [,position ,[,occurrence [,match_option]]])

(1) :search_string是搜索值

(2):parrern 是使用得正规表达式且其长度限制在512字节内

(3)position 是一个表示搜索开始位置的正整数，默认为一。

(4)occurrence定义了搜索模式的发生次数，默认为一，

(5)match_option 是设置该函数匹配行为的参数

Eg:

Select last_name,regexp_substr(last_name,’[rst][a-z]{4}’) from authors where length(regexp_sustr(last_name,[rst][a_z]{4}));

1．原子性(atomicity)  --事务处理要么全部进行，要么不进行。

2．一致性(consistency) –事务处理要将数据库从一种状态转变为另        一种状态。

3．隔离性(isolation) –在事务处理提交之前，事务处理的效果不能由系统中的其他事务看到。

4．持久性(durability) –一旦提交了事务，他就永远生效。

5．set autocommit on--设置数据库系统环境为自动提交事务：

SQL> set autocommit on;

SQL> insert into t values(1,'2','2');

已创建 1 行。

提交完成。

SQL> set autocommit off;

SQL> insert into t values(1,'2','2');

已创建 1 行。

SQL> commit;

提交完成。

6．锁：（防止进程之间因为抢占资源，产生死锁而设定一种预防死锁产生的机制）

允许或者拒绝资源访问的一种机制

为了防止用户在同一时间内并发的访问和修改数据库资源，orcale中使用不同类型的锁控制对数据的并发访问，以防止用户之间出现破坏性的操作。

锁定的类型：

（1）行级锁：行被排他锁定

（2）表级锁：共享锁，共享更新锁，排他锁

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

行级锁：

行被排他锁定，在某行的锁被释放之前，其他用户不能修改此行，使用 commit 或 rollback 命令释放锁

Oracle 通过使用 INSERT、UPDATE 和 SELECT…FOR UPDATE 语句自动获取行级锁

SELECT…FOR UPDATE 子句

在表的一行或多行上放置排他锁，用于防止其他用户更新该行，可以执行除更新之外的其他操作，只有该用户提交事务，其他用户才能够更新gname

select * from goods where gid=1001

for update of gname;

server1：                                            server2

create table goods (gid int );               

insert into goods values(1)  

insert into goods values(2)  

别的进程访问该表时,可以执行除更新之外的其他操作    

select * from goods where gid=1 for update of gid    访问server1时，可以对goods表进行添加，删除，查询，但不能修改

FOR UPDATE WAIT 子句是Oracle9i 中的新增功能：

为了防止无限期地等待锁定的行，等待间隔必须指定为数值文字，等待间隔不能是表达式、赋值变量或 PL/SQL。
变量

select * from goods where gid=1001 for update of gname wait  3

等待用户释放更新锁的时间为3秒，否则超时。

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

表级锁：

保护表的数据

在多个用户同时访问数据时确保数据的完整性

可以设置为三种模式：共享、共享更新和排他

语法：

        Lock table < table_name> in  <mode>;

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

共享锁：仅允许其他用户执行查询操作，不能插入、更新和删除，多个用户可以同时在同一表中放置此锁

Lock  table  table_name

in share  mode   [nowait];

rollback   和commit命令释放锁

Nowait  关键字告诉其他用户不用等待

lock table<tabale_name>[,<table_name>,....]

in share mode[nowait]

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

共享更新锁：

锁定要被更新的行

允许其他用户同时查询、插入、更新未被锁定的行

在 SELECT 语句中使用“FOR UPDATE”子句，可以强制使用共享更新锁

允许多个用户同时锁定表的不同行

加锁的两种方法

(1)lock table tab_name in share update mode;

(2)Select column1, column2 From  goods Where gid=1001  For update of column1, column2

lock table<tabale_name>[,<table_name>,....] in share update mode [nowait]

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

排他锁：

与其他两种锁相比，排他锁是限制性最强的表锁，仅允许其他用户查询数据，不允许执行插入、删除和更新操作，在同一时间仅允许一位用户在表上放置排他锁

共享锁与此相反

lock table<tabale_name>[,<table_name>,....]

in exclusive mode [nowait]

1．表的创建：

create table table_name(column_name datatype[,column_name datatype])

2．表数据的插入：

insert into table_name values(column_instance)

3．更新数据：

update table_name set column_instance=? where column_name=?

4．查询数据：

select * from table_name where condition1 group by column_name1... having.... order by column_name[desc,[asc]]

5．删除数据：

delete from table_name where column_name1=?

6．在表空间上建立表：

create table tablename(column_name,datatype)tablespace tablespace_name

7．oracle中提供5种约束：

Check，not null，unique，primary key，foreign key

(a)check约束

Create table policies(policy_id number ,holder_name varchar2(40),gender varchar2 (1) constraint chk_gender check (gender in ('M','F'),marital_status varchar2 (1),
date_of_birth date ,constraint chk_marital check (marital_status in('S','M','D','W')));

(b)not null约束

Create table policies(policy_id number ,holder_name varchar2 (40) not null,gender varchar2(1),marital_status varchar2(1),date_of_birth date not null);　　

对于not null的alter table语句与其他约束稍微有点不同。Alter table policies modify holder_name not null

(c)unique约束

create table  emp(eid  int ,ename  varchar2(10),constraint uq unique(eid,ename))

create  table  emp (eid  int ,ename  varchar(10))

alter table emp  add  constraint pk  primary key(eid,ename);

8。

(a)添加新列

alter table table_name add column_name datatype [constraint][constraint_name]

(b) 添加新列并指定默认值

alter table table_name add column_name datatype default expression

alter table table_name drop column column_name--删除列

alter table table_name modify column_name datatype--修改类属性

alter table table_name disable constraint constraint_name--禁用约束

alter table table_name enable constraint constraint_name--启用约束

alter table table_name add constraint constraint_name constraint_type(column_name)--添加约束

alter table table_name drop constraint constraint_name [cascade]--删除约束

--组合主健（可以用多个列组合成一个主健）

--匿名块的实例：
CREATE TABLE authors (
   id          NUMBER PRIMARY KEY,
   first_name VARCHAR2(50),
   last_name   VARCHAR2(50)
);

CREATE TABLE books (
   isbn       CHAR(10) PRIMARY KEY,
   category   VARCHAR2(20),
   title      VARCHAR2(100),
   num_pages NUMBER,
   price      NUMBER,
   copyright NUMBER(4),
   author1    NUMBER CONSTRAINT books_author1
             REFERENCES authors(id),
   author2    NUMBER CONSTRAINT books_author2
             REFERENCES authors(id),
   author3    NUMBER CONSTRAINT books_author3
             REFERENCES authors(id)
);

CREATE TABLE inventory (
   isbn          CHAR(10) CONSTRAINT fk_isbn REFERENCES books (isbn),
   status        VARCHAR2(25) CHECK (status IN ('IN STOCK', 'BACKORDERED', 'FUTURE')),
   status_date   DATE,
   amount        NUMBER
);
INSERT INTO authors (id, first_name, last_name)
   VALUES (1, 'Marlene', 'Theriault');

INSERT INTO authors (id, first_name, last_name)
   VALUES (2, 'Rachel', 'Carmichael');

INSERT INTO authors (id, first_name, last_name)
   VALUES (3, 'James', 'Viscusi');

INSERT INTO books (isbn, category, title, num_pages, price, copyright, author1, author2, author3)
   VALUES ('72121203', 'Oracle Basics', 'Oracle DBA 101', 563, 39.99, 1999, 1, 2, 3);

INSERT INTO inventory (isbn, status, status_date, amount)
   VALUES ('72121203', 'BACKORDERED', TO_DATE('06-JUN-2004', 'DD-MON-YYYY'), 1000);

SET SERVEROUTPUT ON ESCAPE OFF--当退出该匿名块时就关闭SERVEROUTPUT
DECLARE
    v_first_name authors.first_name%TYPE;   --声明和定义变量
    v_last_name authors.last_name%TYPE;
    v_row_count PLS_INTEGER := 0;
    CURSOR auth_cur IS    --声明游标
       SELECT a.first_name, a.last_name, count(b.title)
       FROM authors a, books b
       WHERE a.id = b.author1
       OR a.id = b.author2
       OR a.id = b.author3
       GROUP BY a.first_name, a.last_name
       HAVING count(b.title) > 0
       ORDER BY a.last_name;
BEGIN
    DBMS_OUTPUT.ENABLE(1000000);
    OPEN auth_cur;   --打开游标
    LOOP
       FETCH auth_cur INTO v_first_name, v_last_name, v_row_count;--推进游标
       EXIT WHEN auth_cur%NOTFOUND;   --当没有发现数据时，推出
       DBMS_OUTPUT.PUT_LINE(v_last_name
                            ||', '
                            ||v_first_name
                            ||' wrote '
                            ||v_row_count
                            ||' book(s).');
    END LOOP;   
    CLOSE auth_cur;   --关闭游标
EXCEPTION            --异常处理部分
    WHEN OTHERS       --others表示其它别的异常
       THEN
       DBMS_OUTPUT.PUT_LINE(SQLERRM);
END;

可以直接在insert into test values(SEQNAME.NEXTVAL) 是可以用这样：     

SELECT tmpdata_seq.NEXTVAL
        INTO id_temp
        FROM DUAL;  然后可以用id_temp

(2)PLS-00103: 出现符号 ">"在需要下列之一时：
代码如下：     

 IF (sum>0)
      THEN
   begin
         INSERT INTO emesp.tp_sn_production_log
              VALUES (r_serial_number, , id_temp);

         EXIT;
    end; 

一直报sum>0 这是个很郁闷的问题 因为变量用了sum  所以不行，后改为i_sum>0

(3)oracle 语法

1. Oracle应用编辑方法概览
答：1) Pro*C/C++/... : C语言和数据库打交道的方法，比OCI更常用;
    2) ODBC
    3) OCI: C语言和数据库打交道的方法，和ProC很相似，更底层，很少用;
    4) SQLJ: 很新的一种用Java访问Oracle数据库的方法，会的人不多;
    5) JDBC
    6) PL/SQL: 存储在数据内运行, 其他方法为在数据库外对数据库访问;

2. PL/SQL
答：1) PL/SQL(Procedual language/SQL)是在标准SQL的基础上增加了过程化处理的语言;
    2) Oracle客户端工具访问Oracle服务器的操作语言;
    3) Oracle对SQL的扩充;

4. PL/SQL的优缺点
答：优点：
    1) 结构化模块化编程，不是面向对象;
    2) 良好的可移植性(不管Oracle运行在何种操作系统);
    3) 良好的可维护性(编译通过后存储在数据库里);
    4) 提升系统性能;

    第二章

PL/SQL程序结构

1. PL/SQL块
答：1) 申明部分, DECLARE(不可少);
    2) 执行部分, BEGIN...END;
    3) 异常处理，EXCEPTION(可以没有);

2. PL/SQL开发环境
答：可以运用任何纯文本的编辑器编辑，例如：VI    ；toad很好用

3. PL/SQL字符集
答：PL/SQL对大小写不敏感

4. 标识符命名规则
答：1) 字母开头;
    2) 后跟任意的非空格字符、数字、货币符号、下划线、或# ;
    3) 最大长度为30个字符(八个字符左右最合适);

5. 变量声明
答：语法
    Var_name type [CONSTANT][NOT NULL][:=value];
    注：1) 申明时可以有默认值也可以没有;
        2) 如有[CONSTANT][NOT NULL], 变量一定要有一个初始值;
        3) 赋值语句为“:=”;
        4) 变量可以认为是数据库里一个字段;
        5) 规定没有初始化的变量为NULL;

第三章

1. 数据类型
答：1) 标量型：数字型、字符型、布尔型、日期型;
    2) 组合型：RECORD(常用)、TABLE(常用)、VARRAY(较少用)
    3) 参考型：REF CURSOR(游标)、REF object_type
    4) LOB(Large Object)

2. %TYPE
答：变量具有与数据库的表中某一字段相同的类型
    例：v_FirstName studengts.first_name%TYPE;

3. RECORD类型
答：TYPE record_name IS RECORD(            /*其中TYPE，IS，RECORD为关键字，record_name为变量名称*/
 field1 type [NOT NULL][:=expr1],   /*每个等价的成员间用逗号分隔*/
 field2 type [NOT NULL][:=expr2],   /*如果一个字段限定NOT NULL，那么它必须拥有一个初始值*/
        ...                                /*所有没有初始化的字段都会初始为NULL
 fieldn type [NOT NULL][:=exprn]);

4. %ROWTYPE
答：返回一个基于数据库定义的类型
    DECLARE
      v_StuRec Student%ROWTYPE;            /*Student为表的名字*/

    注：与3中定一个record相比，一步就完成，而3中定义分二步：a. 所有的成员变量都要申明; b. 实例化变量;

5. TABLE类型
答：TYPE tabletype IS TABLE OF type INDEX BY BINARY_INTEGER;
    例：DECLARE
          TYPE t_StuTable IS TABLE OF Student%ROWTYPE INDEX BY BINARY_INTERGER;
          v_Student t_StuTable;
 BEGIN
          SELECT * INTO v_Student(100) FROM Student WHERE id = 1001;
        END;
    注：1) 行的数目的限制由BINARY_INTEGER的范围决定;

6. 变量的作用域和可见性
答：1) 执行块里可以嵌入执行块;
    2) 里层执行块的变量对外层不可见;
    3) 里层执行块对外层执行块变量的修改会影响外层块变量的值;

第四章

1. 条件语句
答：IF boolean_expression1 THEN
    ...
    ELSIF boolean_expression2 THEN   /*注意是ELSIF，而不是ELSEIF*/
    ...                              /*ELSE语句不是必须的，但END IF;是必须的*/
    ELSE
    ...
    END IF;

2. 循环语句
答：1) Loop
       ...
         IF boolean_expr THEN        /* */
            EXIT;                    /* EXIT WHEN boolean_expr */
         END IF;                     /* */
       END LOOP;
    2) WHILE boolean_expr LOOP
       ...
       END LOOP;
    3) FOR loop_counter IN [REVERSE] low_blound..high_bound LOOP
       ...
       END LOOP;
       注：a. 加上REVERSE 表示递减，从结束边界到起始边界，递减步长为一;
           b. low_blound  起始边界; high_bound  结束边界;

3. GOTO语句
答：GOTO label_name;
    1) 只能由内部块跳往外部块;
    2) 设置标签：<<label_name>>
    3) 示例：
       LOOP
       ...
         IF D%ROWCOUNT = 50 THEN
            GOTO l_close;
         END IF;
       ...
       END LOOP;
       <<l_close>>;
       ...

4. NULL语句
答：在语句块中加空语句，用于补充语句的完整性。示例：
    IF boolean_expr THEN
    ...
    ELSE
      NULL;
    END IF;

5. SQL in PL/SQL
答：1) 只有DML SQL可以直接在PL/SQL中使用;

第五章

1. 游标(CURSOR)
答：1) 作用：用于提取多行数据集;
    2) 声明：a. 普通申明：DELCARE CURSOR CURSOR_NAME IS select_statement  /* CURSOR的内容必须是一条查询语句*/
             b. 带参数申明：DELCARE CURSOR c_stu(p_id student.ID%TYPE) SELECT * FROM student WHERE ID = p_id;
    3) 打开游标：OPEN Cursor_name;   /*相当于执行select语句，且把执行结果存入CURSOR;
    4) 从游标中取数：a. FETCH cursor_name INTO var1, var2, ...; /*变量的数量、类型、顺序要和Table中字段一致;*/
                     b. FETCH cursor_name INTO record_var;
       注：将值从CURSOR取出放入变量中，每FETCH一次取一条记录;
    5) 关闭游标: CLOSE Cursor_name;
       注：a. 游标使用后应该关闭;
           b. 关闭后的游标不能FETCH和再次CLOSE;
           c. 关闭游标相当于将内存中CURSOR的内容清空;

2. 游标的属性
答：1) %FOUND:    是否有值;
    2) %NOTFOUND: 是否没有值;
    3) %ISOPEN:   是否是打开状态;
    4) %ROWCOUNT: CURSOR当前的记录号;

3. 游标的FETCH循环
答：1) LOOP
         FETCH cursor INTO ...
         EXIT WHEN cursor%NOTFOUND;   /*当cursor中没记录后退出*/
       END LOOP;
    2) WHILE cursor%FOUND LOOP
         FETCH cursor INTO ...
       END LOOP;
    3) FOR var IN cursor LOOP
         FETCH cursor INTO...
       END LOOP;
      
第六章

1. 异常
答：DECLARE
      ...
      e_TooManyStudents EXCEPTION;  /* 申明异常 */
      ...
    BEGIN
      ...
      RAISE e_TooManyStudents;      /* 触发异常 */
      ...
    EXCEPTION
      WHEN e_TooManyStudents THEN   /* 触发异常 */
      ...
      WHEN OTHERS THEN              /* 处理所有其他异常 */
      ...
    END;

2004-9-8     星期三    阴

PL/SQL数据库编程(下)

1. 存储过程(PROCEDURE)
答：创建过程：
    CREATE [OR REPLACE] PROCEDURE proc_name
         [(arg_name[{IN|OUT|IN OUT}]TYPE,
           arg_name[{IN|OUT|IN OUT}]TYPE)]
          {IS|AS}
    procedure_body
    1) IN: 表示该参数不能被赋值(只能位于等号右边);
    2) OUT:表示该参数只能被赋值(只能位于等号左边);
    3) IN OUT: 表示该类型既能被赋值也能传值;

2. 存储过程例子
答：CREATE OR REPLACE PROCEDURE ModeTest(
        p_InParm IN NUMBER,
        p_OutParm OUT NUMBER,
        p_InOutParm IN OUT NUMBER)
    IS
        v_LocalVar NUMBER;                      /* 声明部分 */
    BEGIN
        v_LocalVar:=p_InParm;                   /* 执行部分 */
        p_OutParm:=7;
        p_InOutParm:=7;
        ...
    EXCEPTION
        ...                                     /* 异常处理部分 */
    END ModeTest;
   
3. 调用PROCEDURE的例子
答：1) 匿名块可以调;
    2) 其他PROCDEURE可以调用;
    例：
    DECLARE
        v_var1 NUMBER;
    BEGIN
        ModeTest(12, v_var1, 10);
    END;
    注：此时v_var1等于7

4. 指定实参的模式
答：1) 位置标示法：调用时添入所有参数，实参与形参按顺序一一对应;
    2) 名字标示法：调用时给出形参名字，并给出实参
       ModeTest(p_InParm=>12, p_OutParm=>v_var1, p_Inout=>10);
    注：a. 两种方法可以混用;
        b. 混用时第一个参数必须通过位置来指定。

5. 函数(Function)与过程(Procedure)的区别
答：1) 过程调用本身是一个PL/SQL语句(可以在命令行中通过exec语句直接调用);
    2) 函数调用是表达式的一部分;

6. 函数的声明
答：CREATE [OR REPLACE] PROCEDURE proc_name
        [(arg_name[{IN|OUT|IN OUT}]TYPE,
          arg_name[{IN|OUT|IN OUT}]TYPE)]
    RETURN TYPE
    {IS|AS}
    procedure_body
    注：1) 没有返回语句的函数将是一个错误;

7. 删除过程与函数
答：DROP PROCEDURE proc_name;
    DROP FUNCTION func_name;

第八章

1. 包
答：1) 包是可以将相关对象存储在一起的PL/SQL的结构;
    2) 包只能存储在数据库中，不能是本地的;
    3) 包是一个带有名字的声明;
    4) 相当于一个PL/SQL块的声明部分;
    5) 在块的声明部分出现的任何东西都能出现在包中;
    6) 包中可以包含过程、函数、游标与变量;
    7) 可以从其他PL/SQL块中引用包，包提供了可用于PL/SQL的全局变量。
    8) 包有包头和包主体，如包头中没有任何函数与过程，则包主体可以不需要。

2. 包头
答：1) 包头包含了有关包的内容的信息，包头不含任何过程的代码。
    2) 语法：
       CREATE [OR REPLACE] PACKAGE pack_name {IS|AS}
            procedure_specification|function_specification|

variable_declaration|type_definition|exception_declaration|

cursor_declaration
       END pack_name;
    3) 示例：
       CREATE OR REPLACE PACKAGE pak_test AS
           PROCEDURE RemoveStudent(p_StuID IN students.id%TYPE);
           TYPE t_StuIDTable IS TABLE OF students.id%TYPE INDEX BY BINARY_INTEGER;
       END pak_test;

3. 包主体
答：1) 包主体是可选的，如包头中没有任何函数与过程，则包主体可以不需要。
    2) 包主体与包头存放在不同的数据字典中。
    3) 如包头编译不成功，包主体无法正确编译。
    4) 包主体包含了所有在包头中声明的所有过程与函数的代码。
    5) 示例：
       CREATE OR REPLACE PACKAGE BODY pak_test AS
           PROCEDURE RemoveStudent(p_StuID IN students.id%TYPE) IS
           BEGIN
              ...
           END RemoveStudent;
           TYPE t_StuIDTable IS TABLE OF students.id%TYPE INDEX BY BINARY_INTEGER;
       END pak_test;

4. 包的作用域
答：1) 在包外调用包中过程(需加包名)：pak_test.AddStudent(100010, 'CS', 101);
    2) 在包主体中可以直接使用包头中声明的对象和过程(不需加包名);

5. 包中子程序的重载
答：1) 同一个包中的过程与函数都可以重载;
    2) 相同的过程或函数名字，但参数不同;

6. 包的初始化
答：1) 包存放在数据库中;
    2) 在第一次被调用的时候，包从数据库中调入内存并被初始化;
    3) 包中定义的所有变量都被分配内存;
    4) 每个会话都将拥有自己的包内变量的副本。

第九章

1. 触发器
答：1) 触发器与过程/函数的相同点
       a. 都是带有名字的执行块;
       b. 都有声明、执行体和异常部分;
    2) 触发器与过程/函数的不同点
       a. 触发器必须存储在数据库中;
       b. 触发器自动执行;

2. 创建触发器
答：1) 语法：
       CREATE [OR REPLACE] TRIGGER trigger_name
       {BEFORE|AFTER} triggering_event ON table_reference
       [FOR EACH ROW [WHEN trigger_condition]]
       trigger_body;
    2) 范例：
       CREATE OR REPLACE TRIGGER UpdateMajorStats AFTER INSERT OR DELETE OR UPDATE ON students
       DECLARE
           CURSOR c_Statistics IS
               SELECT * FROM students GROUP BY major;
       BEGIN
           ...
       END Up;

3. 触发器
答：1) 三个语句(INSERT/UPDATE/DELETE);
    2) 二种类型(之前/之后);
    3) 二种级别(row-level/statement-level);
    所以一共有 3 X 2 X 2 = 12

4. 触发器的限制
答：1) 不应该使用事务控制语句;
    2) 不能声明任何LONG或LONG RAW变量;
    3) 可以访问的表有限。

5. 触发器的主体可以访问的表
答：1) 不可以读取或修改任何变化表(被DML语句正在修改的表);
    2) 不可以读取或修改限制表(带有约束的表)的主键、唯一值、外键列。

(4)Java开发中使用Oracle的ORA-01000

很多朋友在Java开发中，使用Oracle数据库的时候，经常会碰到有ORA-01000: maximum open cursors exceeded.的错误。
实际上，这个错误的原因，主要还是代码问题引起的。
ora-01000: maximum open cursors exceeded.
表示已经达到一个进程打开的最大游标数。
这样的错误很容易出现在Java代码中的主要原因是：Java代码在执行conn.createStatement()和conn.prepareStatement()的时候，实际上都是相当与在数据库中打开了一个cursor。尤其是，如果你的createStatement和prepareStatement是在一个循环里面的话，就会非常容易出现这个问题。因为游标一直在不停的打开，而且没有关闭。
一般来说，我们在写Java代码的时候，createStatement和prepareStatement都应该要放在循环外面，而且使用了这些Statment后，及时关闭。最好是在执行了一次executeQuery、executeUpdate等之后，如果不需要使用结果集（ResultSet）的数据，就马上将Statment关闭。
对于出现ORA-01000错误这种情况，单纯的加大open_cursors并不是好办法，那只是治标不治本。实际上，代码中的隐患并没有解除。
而且，绝大部分情况下，open_cursors只需要设置一个比较小的值，就足够使用了，除非有非常特别的要求。

(5)在store procedure中执行 DDL语句
一是：execute immediate 'update '||table_chan||' set '||column_changed||' = '''||v_trans_name||''' where empid = '''||v_empid||'''' ;

二是：The DBMS_SQL package can be used to execute DDL statements directly from PL/SQL.  

这是一个创建一个表的过程的例子。该过程有两个参数：表名和字段及其类型的列表。

CREATE OR REPLACE PROCEDURE ddlproc (tablename varchar2, cols varchar2) AS
  cursor1 INTEGER;
BEGIN
  cursor1 := dbms_sql.open_cursor;
  dbms_sql.parse(cursor1, 'CREATE TABLE ' || tablename ||     ' ( ' || cols || ' )', dbms_sql.v7);
  dbms_sql.close_cursor(cursor1);
end;
/

2 如何找数据库表的主键字段的名称?
SQL>SELECT * FROM user_constraints
WHERE CONSTRAINT_TYPE='P' and table_name='TABLE_NAME';
3 如何查询数据库有多少表?
SQL>select * from all_tables;

4 使用sql统配符

通配符 描述 示例 % 包含零个或更多字符的任意字符串。 WHERE title LIKE '%computer%' 将查找处于书名任意位置的包含单词 computer 的所有书名。 _（下划线） 任何单个字符。 WHERE au_fname LIKE '_ean' 将查找以 ean 结尾的所有 4 个字母的名字（Dean、Sean 等）。 [ ] 指定范围 ([a-f]) 或集合 ([abcdef]) 中的任何单个字符。 WHERE au_lname LIKE '[C-P]arsen' 将查找以arsen 结尾且以介于 C 与 P 之间的任何单个字符开始的作者姓氏，例如，Carsen、Larsen、Karsen 等。 [^] 不属于指定范围 ([a-f]) 或集合 ([abcdef]) 的任何单个字符。 WHERE au_lname LIKE 'de[^l]%' 将查找以 de 开始且其后的字母不为 l 的所有作者的姓氏。

5使普通用户有查看v$Session的权限

GRANT SELECT
    ON  "SYS"."V_$OPEN_CURSOR" TO "SFISM4"; 
GRANT SELECT
    ON  "SYS"."V_$SESSION" TO "SFISM4";

常用函数

 distinct
去掉重复的
minus 相减
在第一个表但不在第二个表
SELECT * FROM FOOTBALL MINUS SELECT * FROM SOFTBALL;
intersect 相交
INTERSECT 返回两个表中共有的行。
SELECT * FROM FOOTBAL；
UNION ALL 与UNION 一样对表进行了合并但是它不去掉重复的记录。
汇总函数
count
select count(*) from test;
SUM
SUM 就如同它的本意一样它返回某一列的所有数值的和。
SELECT SUM(SINGLES) TOTAL_SINGLES FROM TEST;
SUM 只能处理数字如果它的处理目标不是数字你将会收到如下信息
输入/输出
SQL>SELECT SUM(NAME) FROM TEAMSTATS;
ERROR
ORA-01722 invalid number
no rows selected
该错误信息当然的合理的因为NAME 字段是无法进行汇总的。
AVG
AVG 可以返回某一列的平均值。
SELECT AVG(SO) AVE_STRIKE_OUTS FROM TEAMSTATS；
MAX
如果你想知道某一列中的最大值请使用MAX。
SELECT MAX(HITS) FROM TEAMSTATS;
MIN
MIN 与MAX 类似它返回一列中的最小数值。
VARIANCE
VARIANCE 方差不是标准中所定义的但它却是统计领域中的一个至关重要的数值。
SELECT VARIANCE(HITS)  FROM TEAMSTATS;
STDDEV
这是最后一个统计函数STDDEV 返回某一列数值的标准差。
SELECT STDDEV HITS FROM TEAMSTATS；
日期时间函数
ADD_MONTHS 
 ADD_MONTHS也可以工作在select 之外
该函数的功能是将给定的日期增加一个月举例来说由于一些特殊的原因上述的计划需要推迟两个月那么就用到了。
LAST_DAY
LAST_DAY 可以返回指定月份的最后一天.
MONTHS_BETWEEN
如果你想知道在给定的两个日期中有多少个月可以使用MONTHS_BETWEEN。
select task, startdate, enddate ,months between(Startdate,enddate) duration from project;
返回结果有可能是负值.
可以利用负值来判断某一日期是否在另一个日期之前下例将会显示所有在1995 年5 月19 日以前开始的比赛.
SELECT * FROM PROJECT
WHERE MONTHS_BETWEEN ('19-MAY-95', STARTDATE)>0;
NEW_TIME
如果你想把时间调整到你所在的时区你可以使用NEW_TIME.
SQL>SELECT ENDDATE EDT, NEW_TIME('ENDDATE',' EDT',' PDT') FROM PROJECT;
NEXT_DAY
NEXT_DAY 将返回与指定日期在同一个星期或之后一个星期内的你所要求的星期天
数的确切日期如果你想知道你所指定的日期的星期五是几号可以这样做.
SQL>SELECT STARTDATE, NEXT_DAY(STARTDATE,' FRIDAY') FROM PROJECT;
SYSDATE
SYSDATE 将返回系统的日期和时间。
SELECT DISTINCT SYSDATE FROM PROJECT；
数学函数
ABS
ABS 函数返回给定数字的绝对值
CEIL 和FLOOR
CEIL 返回与给定参数相等或比给定参数在的最小整数.FLOOR 则正好相反它返回
与给定参数相等或比给定参数小的最大整数.
COS COSH SIN SINH TAN TANH
COS SIN TAN 函数可以返回给定参数的三角函数值默认的参数认定为弧度制.
EXP
EXP 将会返回以给定的参数为指数以e 为底数的幂.
LN and LOG
这是两个对数函数其中LN 返回给定参数的自然对数.
MOD
知道在ANSI 标准中规定取模运算的符号为%在一些解释器中被函数MOD 所取代.
POWER
该函数可以返回某一个数对另一个数的幂在使用幂函数时第一个参数为底数第二个为指数。
SIGN
如果参数的值为负数那么SIGN 返回-1 如果参数的值为正数那么SIGN 返回1,如果参数为零那么SIGN 也返回零.
SQRT
该函数返回参数的平方根,由于负数是不能开平方的所以我们不能将该函数应用于负数.
字符函数
CHR
该函数返回与所给数值参数等当的字符返回的字符取决于数据库所依赖的字符集.
CONCAT
和||一个作用，把两个字符串连接起来.
INITCAP
该函数将参数的第一个字母变为大写此外其它的字母则转换成小写.
LOWER 和UPPER
如你所料LOWER 将参数转换为全部小写字母而UPPER 则把参数全部转换成大写字母.
LPAD 与RPAD
这两个函数最少需要两个参数最多需要三个参数每一个参数是需要处理的字符串
第二个参数是需要将字符串扩充的宽度第三个参数表示加宽部分用什么字符来做填补
第三个参数的默认值为空格但也可以是单个的字符或字符串.
LTRIM 与RTRIM
LTRIM 和RTRIM至少需要一个参数最多允许两个参数第一个参数与LPAD 和RPAD
类似是一个字符串第二个参数也是一个字符或字符串默认则是空格如果第二个
数不是空格的话那么该函数将会像剪除空格那样剪除所指定的字符.
REPLACE
它的工作就如果它的名字所说的那样该函数需要三个参数第一个参数是需要搜索
的字符串(列名），第二个参数是搜索的内容第三个参数则是需要替换成的字符串如果第三个
参数省略或者是NULL 那么将只执行搜索操作而不会替换任何内容.
SUBSTR
这个函数有三个参数允许你将目标字符串的一部份输出，第一个参数为目标字符串，
第二个字符串是将要输出的子串的起点，第三个参数是将要输出的子串的长度。
如果第二个参数为负数那么将会从源串的尾部开始向前定位至负数的绝对值的位置。
TRANSLATE
这一函数有三个参数，目标字符串、源字符串和目的字符串，在目标字符串与源字符
串中均出现的字符将会被替换成对应的目的字符串的字符。
INSTR
如果需要知道在一个字符串中满足特定的内容的位置可以使用INSTR ，它的第一个参
数是目标字符串，第二个参数是匹配的内容，第三和第四个参数是数字用以指定开始搜
索的起点以及指出第几个满足条件的将会被返回。
LENGTH
LENGTH将返回指定字符串的长度。
转换函数
转换函数有三个可以使你方便地将数据从一种类型变换为另一种类型。
TO_CHAR
该函数的最初功能是将一个数字转换为字符型，不同的解释器可能会使用它来转换其它的
数据类型例如日期型转换为字符型或者是拥有更多的参数。
TO_NUMBER
该函数与TO_CHAR 函数相对应显而易见它是将一个字符串型数字转换为数值型。
其他函数
GREATEST 与LEAST
这两个函数将返回几个表达式中最大的和最小的。
SELECT GREATEST（‘ALPHA’，‘ BRAVO’，‘ FOXTROT’，‘ DELTA’） FROM CONVERT；
看来有必要使用FROM 子句可是如果FROM 子句没有的话你将会收到一个错误信息每
一个SELECT 语句都需要FROM 子句。
USER
该函数返回当前使用数据库的用户的名字

存储过程为：

CREATE OR REPLACE PROCEDURE TESTA(PARA1 IN VARCHAR2,PARA2 IN VARCHAR2)  AS

BEGIN

   INSERT INTO HYQ.B_ID (I_ID,I_NAME) VALUES (PARA1, PARA2);

END TESTA;

然后呢，在java里调用时就用下面的代码：

package com.hyq.src;

import java.sql.*;

import java.sql.ResultSet;

public class TestProcedureOne {

  public TestProcedureOne() {

  }

  public static void main(String[] args ){

    String driver = "oracle.jdbc.driver.OracleDriver";

    String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521: hyq ";

    Statement stmt = null;

    ResultSet rs = null;

    Connection conn = null;

    CallableStatement cstmt = null;

    try {

      Class.forName(driver);

      conn =  DriverManager.getConnection(strUrl, " hyq ", " hyq ");

      CallableStatement proc = null;

      proc = conn.prepareCall("{ call HYQ.TESTA(?,?) }");

      proc.setString(1, "100");

      proc.setString(2, "TestOne");

      proc.execute();

    }

    catch (SQLException ex2) {

      ex2.printStackTrace();

    }

    catch (Exception ex2) {

      ex2.printStackTrace();

    }

    finally{

      try {

        if(rs != null){

          rs.close();

          if(stmt!=null){

            stmt.close();

          }

          if(conn!=null){

            conn.close();

          }

        }

      }

      catch (SQLException ex1) {

      }

    }

  }

}

当然了，这就先要求要建张表TESTTB,里面两个字段（I_ID，I_NAME）。

二：有返回值的存储过程（非列表）

存储过程为：

CREATE OR REPLACE PROCEDURE TESTB(PARA1 IN VARCHAR2,PARA2 OUT VARCHAR2)  AS

BEGIN

   SELECT INTO PARA2 FROM TESTTB WHERE I_ID= PARA1;

END TESTB;

在java里调用时就用下面的代码：

package com.hyq.src;

public class TestProcedureTWO {

  public TestProcedureTWO() {

  }

  public static void main(String[] args ){

    String driver = "oracle.jdbc.driver.OracleDriver";

    String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521:hyq";

    Statement stmt = null;

    ResultSet rs = null;

    Connection conn = null;

    try {

      Class.forName(driver);

      conn =  DriverManager.getConnection(strUrl, " hyq ", " hyq ");

      CallableStatement proc = null;

      proc = conn.prepareCall("{ call HYQ.TESTB(?,?) }");

      proc.setString(1, "100");

      proc.registerOutParameter(2, Types.VARCHAR);

      proc.execute();

      String testPrint = proc.getString(2);

      System.out.println("=testPrint=is="+testPrint);

    }

    catch (SQLException ex2) {

      ex2.printStackTrace();

    }

    catch (Exception ex2) {

      ex2.printStackTrace();

    }

    finally{

      try {

        if(rs != null){

          rs.close();

          if(stmt!=null){

            stmt.close();

          }

          if(conn!=null){

            conn.close();

          }

        }

      }

      catch (SQLException ex1) {

      }

    }

  }

}

}

注意，这里的proc.getString(2)中的数值2并非任意的，而是和存储过程中的out列对应的，如果out是在第一个位置，那就是proc.getString(1)，如果是第三个位置，就是proc.getString(3)，当然也可以同时有多个返回值，那就是再多加几个out参数了。

三：返回列表

由于oracle存储过程没有返回值，它的所有返回值都是通过out参数来替代的，列表同样也不例外，但由于是集合，所以不能用一般的参数，必须要用pagkage了.所以要分两部分，

1，  建一个程序包。如下：

CREATE OR REPLACE PACKAGE TESTPACKAGE AS

TYPE Test_CURSOR IS REF CURSOR;

end TESTPACKAGE;

2，建立存储过程，存储过程为：

CREATE OR REPLACE PROCEDURE TESTC(p_CURSOR out TESTPACKAGE.Test_CURSOR) IS

BEGIN

    OPEN p_CURSOR FOR SELECT * FROM HYQ.TESTTB;

END TESTC;

可以看到，它是把游标（可以理解为一个指针），作为一个out 参数来返回值的。

在java里调用时就用下面的代码：

package com.hyq.src;

import java.sql.*;

import java.io.OutputStream;

import java.io.Writer;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import oracle.jdbc.driver.*;

public class TestProcedureTHREE {

  public TestProcedureTHREE() {

  }

  public static void main(String[] args ){

    String driver = "oracle.jdbc.driver.OracleDriver";

    String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521:hyq";

    Statement stmt = null;

    ResultSet rs = null;

    Connection conn = null;

    try {

      Class.forName(driver);

      conn =  DriverManager.getConnection(strUrl, "hyq", "hyq");

      CallableStatement proc = null;

      proc = conn.prepareCall("{ call hyq.testc(?) }");

      proc.registerOutParameter(1,oracle.jdbc.OracleTypes.CURSOR);

      proc.execute();

      rs = (ResultSet)proc.getObject(1);

      while(rs.next())

      {

          System.out.println("<tr><td>" + rs.getString(1) + "</td><td>"+rs.getString(2)+"</td></tr>");

      }

    }

    catch (SQLException ex2) {

      ex2.printStackTrace();

    }

    catch (Exception ex2) {

      ex2.printStackTrace();

    }

    finally{

      try {

        if(rs != null){

          rs.close();

          if(stmt!=null){

            stmt.close();

          }

          if(conn!=null){

            conn.close();

          }

        }

      }

      catch (SQLException ex1) {

      }

    }

  }

}

在这里要注意，在执行前一定要先把oracle的驱动包放到class路径里，否则会报错的。

Oracle对Oracle9i SQL 做了一些很重要的改进，包括一些令人兴奋的新特点，支持1：5的数量级和ISO99中的SQL标准。作为Oracle的补充，它包括以下新的TABLE JOIN的句法结构：

CROSS　IN——它在两个表格中创建了一个卡迪尔列，就象是在Oracle8i中没写WHERE时那样。

NATURAL JOIN——这是一个很有用的Oracle9i的句法，它通过从WHERE子句中移动连接标准来改善SQL的稳定性

USING子句——它可以通过名字来具体指定连接

ON子句——这个句法允许在两个表格中为连接具体指定栏目的名头
LEFT OUTER JOIN——它返回表格中左边的行和右边的数值，如果没有搭配的行的话，则返回零

RIGHT OUTER JOIN——它返回表格中右边的行和左边的数值，如果没有搭配的行的话，则返回零

FULL OUTER JOIN——它返回的是两个表格中所有的行，用零填满每一个空格。这在Oracle8i中则没有相应的此种句法

大多数改进都是为了让那些非Oracle的请求以快速的进入Oracle数据库而引进的，并且必须记住这些只是句法上的不同，ISO99标准并没有给Oracle9i SQL带来任何新的功能。

The CROSS JOIN
在Oracle中，CROSS JOIN产生了一个“卡迪尔的产物（Cartesian product）”，就象是在连接两个表格时忘记加入一个WHERE子句一样
select last_name,dept_id
from emp,depts;

在Oracle9i中，我们使用CROSS JOIN 来达到相同的结果
select last_name.dept_id
from emp
CROSS JOIN dept;

NATURAL JOIN

我喜欢NATURAL JOIN的原因在于它能够通过在两个表格中配对的栏目的名头来自动的检查join。它同时还简化了Oracle9i SQL,由于where子句仅仅只能过滤谓语，当然，NATURAL JOIN要求在每一个表格中的栏目的名字相同。很有意思的是，这种特性甚至在没有主要的或是外来的关键词作为参考是也能起作用

Oracle8i,
Select book_title, sum(quantity)
From book, sales
Where book.book_id = sales.book_id
group by book_title;

Oracle9i
Select book_title, sum(quantity)
from book
natural join sales
group by book_title;

USING子句
假如几个栏目有同样的名字，而你又不想用所有的这些栏目来连接的时候，你就可以用USING子句。在USING子句中所列的栏目的句子中不会有任何的修饰词，包括where子句也不会有
Oracle8i
select dept_id, city
from departments, locations
where departments.location_id = location.location_id;

Oracle9i
select department_name, city
from departments
JOIN locations
USING (location_id);

ON子句
ON子句被用于当在两个表格中的栏目名字不搭配时来连接表格。而连接条件就是where子句中的过滤条件
Oracle8i
select department_name, city
from department, location
where department.location_id = location.loc_id;

Oracle9i
select department_name, city
from department d
JOIN location l
ON (d.location_id = l.id);

易变的连接
易变的连接就是两个以上的表格被连接所用的。ISO SQL 1999标准通常假设表格从左至右连接，连接的条件是能够为现在的连接或以前的与左边的连接相关联的栏目提供参考。
Oracle8i
select emp_id, city_name, dept_name
from location l, department d, emp e
where d.location_id = l.location_id
and d.department_id = e.department_id;

Oracle9i
select emp_id, city_name, dept_name
from locations l
JOIN departments d ON (d.location_id = l.location_id)
JOIN employees e ON (d.department_id = e.department_id);

新的OUTER JOIN句法

ISO99标准把复杂的加号从Oracle outer join中拿出去，并使得outer join SQL更容易理解。

LEFT OUTER JOIN
在LEFT OUTER JOIN中，会返回所有左边表格中的行，甚至在被连接的表格中没有可配对的栏目的情况下也如此。在下边的例子中，返回了所有雇员的姓，甚至包括了那些没有分配到部门的雇员。
Oracle8i
select last_name, dept_id
from emp e, dept d
where e.department_id = d.department_id(+);

Oracle9i
select last_name, dept_id
from emp
LEFT OUTER JOIN Dept
ON e.dept_id = d.dept_id;

RIGHT OUTER JOIN
在RIGHT OUTER JOIN中返回的是表格中所有右边的行，甚至在被连接的表格中没有可配对的栏目的情况下也如此。在这个例子中，返回了所有部门的ID,包括那些没有一个雇员的的部门。
Oracle8i
select last_name, d.dept_id
from employees e, departments d
where e.department_id(+) = d.department_id;

Oracle9i
select last_name, d.dept_id
from employees e
RIGHT OUTER JOIN departments d
ON (e.department_id = d.department_id);

总结

ISO99标准是Oracle改进SQL工具的另一个例子。NATURAL JOIN LEFT OUTER JOIN 和 RIGHT OUTER JOIN是这些改进中最受欢迎的，它们分别简化了SQL句法以及消除了对于复杂句法（比如+）的需要。

SQL*Plus system/manager

2、显示当前连接用户

SQL> show user

3、查看系统拥有哪些用户

SQL> select * from all_users;

4、新建用户并授权

SQL> create user a identified by a;（默认建在SYSTEM表空间下）

SQL> grant connect,resource to a;

5、连接到新用户

SQL> conn a/a

6、查询当前用户下所有对象

SQL> select * from tab;

7、建立第一个表

SQL> create table a(a number);

8、查询表结构

SQL> desc a

9、插入新记录

SQL> insert into a values(1);

10、查询记录

SQL> select * from a;

11、更改记录

SQL> update a set a=2;

12、删除记录

SQL> delete from a;

13、回滚

SQL> roll;

SQL> rollback;

14、提交

SQL> commit;

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

http://www.oradb.net/newuser/cg_sys.htm

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

网上资料很多：

http://www.oraclefan.net/ocp/sql/dba_monitor.txt

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

用户授权:

GRANT ALTER ANY INDEX TO "user_id "

GRANT "dba " TO "user_id ";

ALTER USER "user_id " DEFAULT ROLE ALL

创建用户:

CREATE USER "user_id " PROFILE "DEFAULT " IDENTIFIED BY " DEFAULT TABLESPACE "USERS " TEMPORARY TABLESPACE "TEMP " ACCOUNT UNLOCK;

GRANT "CONNECT " TO "user_id ";

用户密码设定:

ALTER USER "CMSDB " IDENTIFIED BY "pass_word "

表空间创建:

CREATE TABLESPACE "table_space " LOGGING DATAFILE 'C:\ORACLE\ORADATA\dbs\table_space.ora' SIZE 5M

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

1、查看当前所有对象

SQL > select * from tab;

2、建一个和a表结构一样的空表

SQL > create table b as select * from a where 1=2;

SQL > create table b(b1,b2,b3) as select a1,a2,a3 from a where 1=2;

3、察看数据库的大小，和空间使用情况

SQL > col tablespace format a20

SQL > select b.file_id　　文件ID,

　　b.tablespace_name　　表空间,

　　b.file_name　　　　　物理文件名,

　　b.bytes　　　　　　　总字节数,

　　(b.bytes-sum(nvl(a.bytes,0)))　　　已使用,

　　sum(nvl(a.bytes,0))　　　　　　　　剩余,

　　sum(nvl(a.bytes,0))/(b.bytes)*100　剩余百分比

　　from dba_free_space a,dba_data_files b

　　where a.file_id=b.file_id

　　group by b.tablespace_name,b.file_name,b.file_id,b.bytes

　　order by b.tablespace_name

　　/

　　dba_free_space --表空间剩余空间状况

　　dba_data_files --数据文件空间占用情况

4、查看现有回滚段及其状态

SQL > col segment format a30

SQL > SELECT SEGMENT_NAME,OWNER,TABLESPACE_NAME,SEGMENT_ID,FILE_ID,STATUS FROM DBA_ROLLBACK_SEGS;

5、查看数据文件放置的路径

SQL > col file_name format a50

SQL > select tablespace_name,file_id,bytes/1024/1024,file_name from dba_data_files order by file_id;

6、显示当前连接用户

SQL > show user

7、把SQL*Plus当计算器

SQL > select 100*20 from dual;

8、连接字符串

SQL > select 列1 | |列2 from 表1;

SQL > select concat(列1,列2) from 表1;

9、查询当前日期

SQL > select to_char(sysdate,'yyyy-mm-dd,hh24:mi:ss') from dual;

10、用户间复制数据

SQL > copy from user1 to user2 create table2 using select * from table1;

11、视图中不能使用order by，但可用group by代替来达到排序目的

SQL > create view a as select b1,b2 from b group by b1,b2;

12、通过授权的方式来创建用户

SQL > grant connect,resource to test identified by test;

SQL > conn test/test

13、查出当前用户所有表名。

select unique tname from col;

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

/* 向一个表格添加字段 */

alter table alist_table add address varchar2(100);

/* 修改字段 属性 字段为空 */

alter table alist_table modify address varchar2(80);

/* 修改字段名字 */

create table alist_table_copy as select ID,NAME,PHONE,EMAIL,

QQ as QQ2, /*qq 改为qq2*/

ADDRESS from alist_table;

drop table alist_table;

rename alist_table_copy to alist_table

/* 修改表名 */

空值处理

有时要求列值不能为空

create table dept (deptno number(2) not null, dname char(14), loc char(13));

在基表中增加一列

alter table dept

add (headcnt number(3));

修改已有列属性

alter table dept

modify dname char(20);

注：只有当某列所有值都为空时，才能减小其列值宽度。

只有当某列所有值都为空时，才能改变其列值类型。

只有当某列所有值都为不空时，才能定义该列为not null。

例：

alter table dept modify (loc char(12));

alter table dept modify loc char(12);

alter table dept modify (dname char(13),loc char(12));

查找未断连接

select process,osuser,username,machine,logon_time ,sql_text

from v$session a,v$sqltext b where a.sql_address=b.address;

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

1.以USER_开始的数据字典视图包含当前用户所拥有的信息, 查询当前用户所拥有的表信息:

select * from user_tables;

2.以ALL_开始的数据字典视图包含ORACLE用户所拥有的信息,

查询用户拥有或有权访问的所有表信息:

select * from all_tables;

3.以DBA_开始的视图一般只有ORACLE数据库管理员可以访问:

select * from dba_tables;

4.查询ORACLE用户：

conn sys/change_on_install

select * from dba_users;

conn system/manager;

select * from all_users;

5.创建数据库用户：

CREATE USER user_name IDENTIFIED BY password;

GRANT CONNECT TO user_name;

GRANT RESOURCE TO user_name;

授权的格式: grant (权限) on tablename to username;

删除用户(或表):

drop user(table) username(tablename) (cascade);

6.向建好的用户导入数据表

IMP SYSTEM/MANAGER FROMUSER = FUSER_NAME TOUSER = USER_NAME FILE = C:\EXPDAT.DMP COMMIT = Y

7.索引

create index [index_name] on [table_name]( "column_name ")