引自：http://www.7880.com/info/Article-83e62ca0.html


　连续几天安装配置和连接Mysql数据库，今天终于成功了，回想这几天，真的是甜酸苦辣都有，单mysql就重装了不下10次，而在eclipse上编写的连接数据库的程序总是报错．我都已经down了oracal准备放弃mysql了，不过．．．就象电视剧演的那样，转机总是在这个时候出现，先是看到了saulzy关于mysql4.1.11版本的安装介绍，接着又找到了一款不错的mysql 界面插件，最后在网友的帮助下把mysql的JDBC驱动配好并连通了．一连5天，日子真不好过阿，不过这个过程中，我也觉得自己学到不少东西，呵呵，反正都撑过来了，就要继续往前走．现在，就这几天弄的总结一下，希望对同是正在学习JAVA技术的同道中人能有帮助．

　　(相关链接："配置Eclpise+tomcat并实现JSP的编写与部署")

一． 软件下载
　　Mysql
　　下载版本：4.1.11
　　http://dev.mysql.com/downloads/mysql/4.1.html

　　JDBC驱动
　　下载版本：3.1.8
　　http://dev.mysql.com/downloads/connector/j/3.1.html

　　Mysql界面插件:mysql-front
　　下载版本镜像：HongKong（我下回来安装就是中文版了）
　　http://www.mysqlfront.de/download.html

二． 软件安装
　　1.安装mysql
　　请参阅相关文章，推荐文章：http://blog.csdn.net/saulzy/archive/2005/04/23/359648.aspx

　　2.JDBC驱动：mysql-connector-java-3.1.8
　　这只是一个压缩包，并不需要安装，只要将其解压，我么使用的是文件夹mysql-connector-java-3.1.8里的文件：mysql-connector-java-3.1.8-bin.jar．

　　3. Mysql界面插件:mysql-front
　　这是一个安装程序，按照提示安装就可以了．

三． 环境配置
　首先，我要说明的是我现在tomcat的安装路径是: D:\Program Files\Java\Tomcat；JDK的安装路径是：D:\Program Files\Java\j2sdk。

　　在这里，需要配置环境变量的是JDBC驱动．在配置前先要把刚才说到的mysql-connector-java-3.1.8-bin.jar本地硬盘某处（我放的地方：D:\Program Files\Java\mysqlforjdbc），然后根据你放的地方，配置classpath，我的配置是这样的：

　　D:\Program files\Java\j2sdk\lib\tools.jar;

　　D:\Program Files\Java\j2sdk\lib\mysql-connector-java-3.1.8-bin-g.jar;

　　D:\Program Files\Java\mysqlforjdbc\mysql-connector-java-3.1.8-bin.jar
　　配置这个的目的是让你的java应用程序找到连接mysql的驱动．

　　配置完环境变量后还有很重要一步就是为JSP连接数据库配置驱动，这个其实很简单，就是把mysql-connector-java-3.1.8-bin.jar拷到某些文件夹里就行了，我在网上看了很多资料问了很多人，各种说法都有，我综合了一下，为了保险，我都全做了，呵呵，反正就是拷一个400K的文件而已，现列出要把mysql-connector-java-3.1.8-bin.jar拷进去的文件夹，如下：
　　D:\Program Files\Java\Tomcat\common\lib
　　D:\Program Files\Java\Tomcat\shared\lib

四． 数据库的使用

　　Mysql安装完毕以后，还有一些要注意的地方（推荐文章）：http://blog.csdn.net/saulzy/archive/2005/04/23/359811.aspx

　　就象在文章提到的，mysql安装好后最重要一样就是要看数据库有没有作为系统服务启动了，所以在大家进行数据库操作前，应要看看，在操作系统的开始－＞运行－＞输入services.msc，确定你在安装时你设置的关于mysql的那个服务已经启动，这样你在操作数据库时不会报连接不上的错误．

　　上面提到了一个较方便的mysql界面插件，但是这个界面是我在已经开始使用mysql后才找到的，刚开始我是在dos下用命令行进行操作的．虽然那个界面也可以进行建库啊，设定权限等操作，但是，我觉得懂得在使用命令行也是一个很重要的技能，所以我先从命令行开始说，怎样简单使用mysql．到后面会谈及mysql－front的使用．

　　现在我想在mysql里建一个数据库shujuku，以及在数据库里建一个表biao．具体的命令如下（假设mysql我是刚安装好的）

　　1. 进入dos状态（记住命令行的要运行在mysql的安装目录下的bin目录的）

　　2. 连接mysql
　　输入：mysql –h localhost –u root –p
　　输入在安装时已设好的密码，就近入了mysql的命令编辑界面了。

　　3. 使用mysql的基本命令(在mysql命令行编辑每输入完命令后最后一定要有分号，不然会报错)
　　显示数据库：show databases;
　　使用数据库：use 数据库名；

　　4．建库
　　命令：create database shujuku;

　　5.为数据库设置权限（用户和密码）
　　命令：grant all privileges on shujuku.* to test@localhost identified by “123456”;
　　当你执行完这个命令以后，只要你再以用户名：test,密码：123456登录时你就只可以对shujuku这个数据库操作，这样避开使用root，对数据库的安全有很大帮助．

　　6.建表
　　命令：create table biao(id int(8) primary key,name varchar(10));

　　剩下来的与标准sqsl命令基本上是一样的，具体操作略
　　值得一提的是，你在命令行上输入＂？＂，就会有mysql命令的简单帮助，如下：

　　呵呵，那样，我们还可以知道退出，就是＂exit＂，呵呵！

五． 关于mysql-front的使用
　　我找了好几个mysql的界面工具，觉得最简洁方便还是mysql-front，可惜的是要收费，不过还好有试用期，呵呵，可以先感受感受一下，最重要一点是mysql-front有简体中文版的，英文不好的我用起来就舒服多了．下面简单说说使用吧．

　　首先，安装就不用说了，有向导，而且很简单．安装好后第一次运行时会跳出来一个要求添加对话的框，在这里你可以添加例如上面已经设定好的shujuku，过程如下:
　　当你在注册的复选框里填上你在上面mysql设定好的用户名和密码后，在选择数据库框里就有shujuku 的数据库了，选上，按确定．进入mysql-fron后，你就会看到下面的界面，这是你就可以进行操作了．

　　要说明的是，你还可以把root用户也加进去，这要你在mysql-fron的界面上选设置－＞对话－＞新建，再按上面进行就可以，出了root你还可以加入更多的用户，方法还是一样的，设置不同的用户，是方便对不同数据库进行管理，呵呵，root是权限最高的，可不要随便让别人使用你的root用户，保正你数据库的安全．

六． JSP连接mysql
　　现在就是尝试用jsp连接mysql了
　　我在eclipse里建了个test_mysql.jsp页面，代码如下：

<%@ page contentType="text/html; charset=gb2312" %>

<%@ page language="java" %>

<%@ page import="com.mysql.jdbc.Driver" %>

<%@ page import="java.sql.*" %>

<%

//驱动程序名

String driverName="com.mysql.jdbc.Driver";

//数据库用户名

String userName="cl41";

//密码

String userPasswd="123456";

//数据库名

String dbName="db";

//表名

String tableName="dbtest";

//联结字符串

String url="jdbc:mysql://localhost/"+dbName+"?user="+userName+"&password="+userPasswd;

Class.forName("com.mysql.jdbc.Driver").newInstance();

Connection connection=DriverManager.getConnection(url);

Statement statement = connection.createStatement();

String sql="SELECT * FROM "+tableName;

ResultSet rs = statement.executeQuery(sql);

//获得数据结果集合

ResultSetMetaData rmeta = rs.getMetaData();

//确定数据集的列数，亦字段数

int numColumns=rmeta.getColumnCount();

// 输出每一个数据值

out.print("id");

out.print("|");

out.print("num");

out.print("<br>");

while(rs.next()) {

out.print(rs.getString(1)+" ");

out.print("|");

out.print(rs.getString(2));

out.print("<br>");

}

out.print("<br>");

out.print("数据库操作成功，恭喜你");

rs.close();

statement.close();

connection.close();

%>

　　然后把test­_mysql.jsp部署到tomcat处，如何部署可参考"配置Eclpise+tomcat并实现JSP的编写与部署"，在浏览器中就可以看到结果了。

作者通过使用JAVA中的动态代理实现数据库连接池，使使用者可以以普通的jdbc连接的使用习惯来使用连接池。

数据库连接池在编写应用服务是经常需要用到的模块，太过频繁的连接数据库对服务性能来讲是一个瓶颈，使用缓冲池技术可以来消除这个瓶颈。我们可以在互联网上找到很多关于数据库连接池的源程序，但是都发现这样一个共同的问题：这些连接池的实现方法都不同程度地增加了与使用者之间的耦合度。很多的连接池都要求用户通过其规定的方法获取数据库的连接，这一点我们可以理解，毕竟目前所有的应用服务器取数据库连接的方式都是这种方式实现的。但是另外一个共同的问题是，它们同时不允许使用者显式的调用Connection.close()方法，而需要用其规定的一个方法来关闭连接。这种做法有两个缺点：

第一：改变了用户使用习惯，增加了用户的使用难度。

首先我们来看看一个正常的数据库操作过程：

int executeSQL(String sql) throws SQLException
{
	Connection conn = getConnection();	//通过某种方式获取数据库连接
	PreparedStatement ps = null;
	int res = 0;
	try{
		ps = conn.prepareStatement(sql);
		res = ps.executeUpdate();
}finally{
try{
ps.close();
}catch(Exception e){}
try{
	conn.close();//
}catch(Exception e){}
}
return res;
}

使用者在用完数据库连接后通常是直接调用连接的方法close来释放数据库资源，如果用我们前面提到的连接池的实现方法，那语句conn.close()将被某些特定的语句所替代。

第二：使连接池无法对之中的所有连接进行独占控制。由于连接池不允许用户直接调用连接的close方法，一旦使用者在使用的过程中由于习惯问题直接关闭了数据库连接，那么连接池将无法正常维护所有连接的状态，考虑连接池和应用由不同开发人员实现时这种问题更容易出现。

综合上面提到的两个问题，我们来讨论一下如何解决这两个要命的问题。

首先我们先设身处地的考虑一下用户是想怎么样来使用这个数据库连接池的。用户可以通过特定的方法来获取数据库的连接，同时这个连接的类型应该是标准的java.sql.Connection。用户在获取到这个数据库连接后可以对这个连接进行任意的操作，包括关闭连接等。

通过对用户使用的描述，怎样可以接管Connection.close方法就成了我们这篇文章的主题。

为了接管数据库连接的close方法，我们应该有一种类似于钩子的机制。例如在Windows编程中我们可以利用Hook API来实现对某个Windows API的接管。在JAVA中同样也有这样一个机制。JAVA提供了一个Proxy类和一个InvocationHandler，这两个类都在java.lang.reflect包中。我们先来看看SUN公司提供的文档是怎么描述这两个类的。

public interface InvocationHandler

InvocationHandler is the interface implemented by the invocation handler of a proxy instance. 

Each proxy instance has an associated invocation handler. 
When a method is invoked on a proxy instance, 
the method invocation is encoded and dispatched to the invoke method of its invocation handler.

SUN的API文档中关于Proxy的描述很多，这里就不罗列出来。通过文档对接口InvocationHandler的描述我们可以看到当调用一个Proxy实例的方法时会触发Invocationhanlder的invoke方法。从JAVA的文档中我们也同时了解到这种动态代理机制只能接管接口的方法，而对一般的类无效，考虑到java.sql.Connection本身也是一个接口由此就找到了解决如何接管close方法的出路。

首先，我们先定义一个数据库连接池参数的类，定义了数据库的JDBC驱动程序类名，连接的URL以及用户名口令等等一些信息，该类是用于初始化连接池的参数，具体定义如下：

public class ConnectionParam implements Serializable
{
	private String driver;				//数据库驱动程序
	private String url;					//数据连接的URL
	private String user;					//数据库用户名
	private String password;				//数据库密码
	private int minConnection = 0;		//初始化连接数
	private int maxConnection = 50;		//最大连接数
	private long timeoutValue = 600000;//连接的最大空闲时间
	private long waitTime = 30000;		//取连接的时候如果没有可用连接最大的等待时间

其次是连接池的工厂类ConnectionFactory，通过该类来将一个连接池对象与一个名称对应起来，使用者通过该名称就可以获取指定的连接池对象，具体代码如下：

/**
 * 连接池类厂，该类常用来保存多个数据源名称合数据库连接池对应的哈希
 * @author liusoft
 */
public class ConnectionFactory
{
	//该哈希表用来保存数据源名和连接池对象的关系表
	static Hashtable connectionPools = null;
	static{
		connectionPools = new Hashtable(2,0.75F);
	} 
	/**
	 * 从连接池工厂中获取指定名称对应的连接池对象
	 * @param dataSource	连接池对象对应的名称
	 * @return DataSource	返回名称对应的连接池对象
	 * @throws NameNotFoundException	无法找到指定的连接池
	 */
	public static DataSource lookup(String dataSource) 
		throws NameNotFoundException
	{
		Object ds = null;
		ds = connectionPools.get(dataSource);
		if(ds == null || !(ds instanceof DataSource))
			throw new NameNotFoundException(dataSource);
		return (DataSource)ds;
	}

	/**
	 * 将指定的名字和数据库连接配置绑定在一起并初始化数据库连接池
	 * @param name		对应连接池的名称
	 * @param param	连接池的配置参数，具体请见类ConnectionParam
	 * @return DataSource	如果绑定成功后返回连接池对象
	 * @throws NameAlreadyBoundException	一定名字name已经绑定则抛出该异常
	 * @throws ClassNotFoundException		无法找到连接池的配置中的驱动程序类
	 * @throws IllegalAccessException		连接池配置中的驱动程序类有误
	 * @throws InstantiationException		无法实例化驱动程序类
	 * @throws SQLException				无法正常连接指定的数据库
	 */
	public static DataSource bind(String name, ConnectionParam param)
		throws NameAlreadyBoundException,ClassNotFoundException,
				IllegalAccessException,InstantiationException,SQLException
	{
		DataSourceImpl source = null;
		try{
			lookup(name);
			throw new NameAlreadyBoundException(name);
		}catch(NameNotFoundException e){
			source = new DataSourceImpl(param);
			source.initConnection();
			connectionPools.put(name, source);
		}
		return source;
	}
	/**
	 * 重新绑定数据库连接池
	 * @param name		对应连接池的名称
	 * @param param	连接池的配置参数，具体请见类ConnectionParam
	 * @return DataSource	如果绑定成功后返回连接池对象
	 * @throws NameAlreadyBoundException	一定名字name已经绑定则抛出该异常
	 * @throws ClassNotFoundException		无法找到连接池的配置中的驱动程序类
	 * @throws IllegalAccessException		连接池配置中的驱动程序类有误
	 * @throws InstantiationException		无法实例化驱动程序类
	 * @throws SQLException				无法正常连接指定的数据库
	 */
	public static DataSource rebind(String name, ConnectionParam param)
		throws NameAlreadyBoundException,ClassNotFoundException,
				IllegalAccessException,InstantiationException,SQLException
	{
		try{
			unbind(name);
		}catch(Exception e){}
		return bind(name, param);
	}
	/**
	 * 删除一个数据库连接池对象
	 * @param name
	 * @throws NameNotFoundException
	 */
	public static void unbind(String name) throws NameNotFoundException
	{
		DataSource dataSource = lookup(name);
		if(dataSource instanceof DataSourceImpl){
			DataSourceImpl dsi = (DataSourceImpl)dataSource;
			try{
				dsi.stop();
				dsi.close();
			}catch(Exception e){
			}finally{
				dsi = null;
			}
		}
		connectionPools.remove(name);
	}
	
}

ConnectionFactory主要提供了用户将将连接池绑定到一个具体的名称上以及取消绑定的操作。使用者只需要关心这两个类即可使用数据库连接池的功能。下面我们给出一段如何使用连接池的代码：

	String name = "pool";
	String driver = " sun.jdbc.odbc.JdbcOdbcDriver ";
	String url = "jdbc:odbc:datasource";
	ConnectionParam param = new ConnectionParam(driver,url,null,null);
	param.setMinConnection(1);
	param.setMaxConnection(5);
	param.setTimeoutValue(20000);
	ConnectionFactory.bind(name, param);
	System.out.println("bind datasource ok.");
	//以上代码是用来登记一个连接池对象，该操作可以在程序初始化只做一次即可
	//以下开始就是使用者真正需要写的代码
	DataSource ds = ConnectionFactory.lookup(name);
	try{
		for(int i=0;i<10;i++){
			Connection conn = ds.getConnection();
			try{
				testSQL(conn, sql);
			}finally{
				try{
					conn.close();
				}catch(Exception e){}
			}
		}
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		ConnectionFactory.unbind(name);
		System.out.println("unbind datasource ok.");
		System.exit(0);
	}

从使用者的示例代码就可以看出，我们已经解决了常规连接池产生的两个问题。但是我们最最关心的是如何解决接管close方法的办法。接管工作主要在ConnectionFactory中的两句代码：

source = new DataSourceImpl(param);
source.initConnection();

DataSourceImpl是一个实现了接口javax.sql.DataSource的类，该类维护着一个连接池的对象。由于该类是一个受保护的类，因此它暴露给使用者的方法只有接口DataSource中定义的方法，其他的所有方法对使用者来说都是不可视的。我们先来关心用户可访问的一个方法getConnection

/**
 * @see javax.sql.DataSource#getConnection(String,String)
 */
	public Connection getConnection(String user, String password) throws SQLException 
	{
		//首先从连接池中找出空闲的对象
		Connection conn = getFreeConnection(0);
		if(conn == null){
			//判断是否超过最大连接数,如果超过最大连接数
			//则等待一定时间查看是否有空闲连接,否则抛出异常告诉用户无可用连接
			if(getConnectionCount() >= connParam.getMaxConnection())
				conn = getFreeConnection(connParam.getWaitTime());
			else{//没有超过连接数，重新获取一个数据库的连接
				connParam.setUser(user);
				connParam.setPassword(password);
				Connection conn2 = DriverManager.getConnection(connParam.getUrl(), 
				user, password);
				//代理将要返回的连接对象
				_Connection _conn = new _Connection(conn2,true);
				synchronized(conns){
					conns.add(_conn);
				}
				conn = _conn.getConnection();
			}
		}
		return conn;
	}
	/**
	 * 从连接池中取一个空闲的连接
	 * @param nTimeout	如果该参数值为0则没有连接时只是返回一个null
	 * 否则的话等待nTimeout毫秒看是否还有空闲连接，如果没有抛出异常
	 * @return Connection
	 * @throws SQLException
	 */
	protected synchronized Connection getFreeConnection(long nTimeout) 
		throws SQLException
	{
		Connection conn = null;
		Iterator iter = conns.iterator();
		while(iter.hasNext()){
			_Connection _conn = (_Connection)iter.next();
			if(!_conn.isInUse()){
				conn = _conn.getConnection();
				_conn.setInUse(true);				
				break;
			}
		}
		if(conn == null && nTimeout > 0){
			//等待nTimeout毫秒以便看是否有空闲连接
			try{
				Thread.sleep(nTimeout);
			}catch(Exception e){}
			conn = getFreeConnection(0);
			if(conn == null)
				throw new SQLException("没有可用的数据库连接");
		}
		return conn;
	}

DataSourceImpl类中实现getConnection方法的跟正常的数据库连接池的逻辑是一致的，首先判断是否有空闲的连接，如果没有的话判断连接数是否已经超过最大连接数等等的一些逻辑。但是有一点不同的是通过DriverManager得到的数据库连接并不是及时返回的，而是通过一个叫_Connection的类中介一下，然后调用_Connection.getConnection返回的。如果我们没有通过一个中介也就是JAVA中的Proxy来接管要返回的接口对象，那么我们就没有办法截住Connection.close方法。

终于到了核心所在，我们先来看看_Connection是如何实现的，然后再介绍是客户端调用Connection.close方法时走的是怎样一个流程，为什么并没有真正的关闭连接。

/**
 * 数据连接的自封装，屏蔽了close方法
 * @author Liudong
 */
class _Connection implements InvocationHandler
{
	private final static String CLOSE_METHOD_NAME = "close";
	private Connection conn = null;
	//数据库的忙状态
	private boolean inUse = false;
	//用户最后一次访问该连接方法的时间
	private long lastAccessTime = System.currentTimeMillis();
	
	_Connection(Connection conn, boolean inUse){
		this.conn = conn;
		this.inUse = inUse;
	}
	/**
	 * Returns the conn.
	 * @return Connection
	 */
	public Connection getConnection() {
		//返回数据库连接conn的接管类，以便截住close方法
		Connection conn2 = (Connection)Proxy.newProxyInstance(
			conn.getClass().getClassLoader(),
			conn.getClass().getInterfaces(),this);
		return conn2;
	}
	/**
	 * 该方法真正的关闭了数据库的连接
	 * @throws SQLException
	 */
	void close() throws SQLException{
		//由于类属性conn是没有被接管的连接，因此一旦调用close方法后就直接关闭连接
		conn.close();
	}
	/**
	 * Returns the inUse.
	 * @return boolean
	 */
	public boolean isInUse() {
		return inUse;
	}

	/**
	 * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object)
	 */
	public Object invoke(Object proxy, Method m, Object[] args) 
		throws Throwable 
	{
		Object obj = null;
		//判断是否调用了close的方法，如果调用close方法则把连接置为无用状态
		if(CLOSE_METHOD_NAME.equals(m.getName()))
			setInUse(false);		
		else
			obj = m.invoke(conn, args);	
		//设置最后一次访问时间，以便及时清除超时的连接
		lastAccessTime = System.currentTimeMillis();
		return obj;
	}
		
	/**
	 * Returns the lastAccessTime.
	 * @return long
	 */
	public long getLastAccessTime() {
		return lastAccessTime;
	}

	/**
	 * Sets the inUse.
	 * @param inUse The inUse to set
	 */
	public void setInUse(boolean inUse) {
		this.inUse = inUse;
	}
}

一旦使用者调用所得到连接的close方法，由于用户的连接对象是经过接管后的对象，因此JAVA虚拟机会首先调用_Connection.invoke方法，在该方法中首先判断是否为close方法，如果不是则将代码转给真正的没有被接管的连接对象conn。否则的话只是简单的将该连接的状态设置为可用。到此您可能就明白了整个接管的过程，但是同时也有一个疑问：这样的话是不是这些已建立的连接就始终没有办法真正关闭？答案是可以的。我们来看看ConnectionFactory.unbind方法，该方法首先找到名字对应的连接池对象，然后关闭该连接池中的所有连接并删除掉连接池。在DataSourceImpl类中定义了一个close方法用来关闭所有的连接，详细代码如下：

	/**
	 * 关闭该连接池中的所有数据库连接
	 * @return int 返回被关闭连接的个数
	 * @throws SQLException
	 */
	public int close() throws SQLException
	{
		int cc = 0;
		SQLException excp = null;
		Iterator iter = conns.iterator();
		while(iter.hasNext()){
			try{
				((_Connection)iter.next()).close();
				cc ++;
			}catch(Exception e){
				if(e instanceof SQLException)
					excp = (SQLException)e;
			}
		}
		if(excp != null)
			throw excp;
		return cc;
	}

该方法一一调用连接池中每个对象的close方法，这个close方法对应的是_Connection中对close的实现，在_Connection定义中关闭数据库连接的时候是直接调用没有经过接管的对象的关闭方法，因此该close方法真正的释放了数据库资源。

以上文字只是描述了接口方法的接管，具体一个实用的连接池模块还需要对空闲连接的监控并及时释放连接，详细的代码请参照附件。

　　软件环境:

　　1、Windows 2000+ORACLE 8.1.7

　　2、ORACLE安装路径为:C:\ORACLE

　　实现方法:

　　1、 开始->设置->控制面板->管理工具->服务 停止所有Oracle服务。

　　2、 开始->程序->Oracle - OraHome81->Oracle Installation Products-> Universal Installer 卸装所有Oracle产品，

　　但Universal Installer本身不能被删除

　　3、 运行regedit，选择HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE，按del键删除这个入口。

　　4、 运行regedit，选择HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services，滚动 这个列表，删除所有Oracle入口。

　　5、 运行refedit， HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Eventlog\Application， 删除所有Oracle入口。

　　6、 开始->设置->控制面板->系统->高级->环境变量 删除环境变量CLASSPATH和PATH中有关Oracle的设定

　　7、 从桌面上、STARTUP(启动)组、程序菜单中，删除所有有关Oracle的组和图标

　　8、 删除\Program Files\Oracle目录

　　9、 重新启动计算机，重起后才能完全删除Oracle所在目录

　　10、 删除与Oracle有关的文件，选择Oracle所在的缺省目录C:\Oracle，

　　删除这个入 口目录及所有子目录，并从Windows 2000目录(一般为C:\WINNT)下

　　删除以下文 件ORACLE.INI、oradim73.INI、oradim80.INI、oraodbc.ini等等。

　　11、 WIN.INI文件中若有[ORACLE]的标记段，删除该段

　　12、 如有必要，删除所有Oracle相关的ODBC的DSN

　　13、 到事件查看器中，删除Oracle相关的日志

　　说明: 如果有个别DLL文件无法删除的情况，则不用理会，重新启动，开始新的安装，

　　安装时，选择一个新的目录，则，安装完毕并重新启动后，老的目录及文件就可以删除掉了。

Oracle触发器在MIS 开发中的应用

                    周海涛   吴良刚

摘要:本文介绍了oracle触发器的概念和类型,总结了oracle触发器在开发MIS中的应用,并提供了实例以供参考.

关键词:MIS 、触发器  oracle

１．引言

    本人在做一个大型的MIS系统（前台用powerbuild工具，后台用oracle数据库）时，常碰到一些有关数据冗长性，批量删除和动态信息方面的问题，由此发现数据库触发器简单易用。现将有关开发和应用中的一些体会总结成文，供同行参考。

２．触发器的概念和类型。

    数据库触发器（database triggers）是响应插入、更新或删除等数据库事件而执行的过程。它定义了当一些数据库相关事件发生时应采取的动作。可用于管理复杂的完整性约束，或监控对表的修改，或通知其它程序，表已发生修改。它的类型有：语句级触发器，以及行级触发器，前者可以在语句执行前或执行后被触发。后者在每个触发语句影响的行触发一次。还有before和after触发的命令。在insert,update,和delete之前或之后执行，引用新旧值进行处理。如果需通过触发器设定插入行中的某列值，则为了访问“新(new)”值，需使用一个触发器before insert，使用after insert则不行。Instead of 触发器命令，使用它告诉oracle应执行什么操作。以上四种大类合成14种小类（略）。各种触发器的执行顺序如下：

如果有，最先执行语句级before触发器。  
每个insert，delete,update影响的行；

1. 如果有，最先执行行级before

2. 执行行的delete或update
3. 如果有,执行行级after触发器

如果有,执行语句级after触发器

３．使用数据库触发器管理数据冗余性

    为了数据分析和制作报表的需要,用户在数据模型中加入了冗余数据，应使用触发器,以保证数据的完整性。

    冗余数据可以用规定的 for each row选项的before update触发器进行管理。update 命令可放在触发器中对所有需要更新的冗余数据进行更新,如客户表和订单表,订单表包括客户的订单和客户表的冗余信息,客户表(customer)的表结构:客户号(cu_no)、客户名(cu_name)、客户地址(cu_address)。订单表(order)的表结构:订单号(or_no),客户号(or_no)，客户名（cu_name），客户地址（cu_address）,当客户基表中的数据被更新时更新订单中的冗余列。语法如下：

       create or replace trigger bj_customer

       before update on customer

       for each row

       begin

           update order set

           cu_no=:new.cu_no，

           cu_name=:new.cu_name，

           cu_address=:new.cu_addess，

           where cu_no=:old.cu_no；

       end; 

４．用触发器完成数据复制

    如果需求非常有限，可以用数据触发器从一个数据库中向另一个数据库复制数据，如果数据复制需求仅与数据的插入有关，当一条记录插入到一个数据库中的某个基表中时，用户还希望把这条记录插入到一个远程数据库中，需用create database link语句创建一条到远程数据库的连接，一旦创建了一条数据库连接后，就可以在基表上创建一个after insert触发器，以把每一条记录插入到远程数据库中。

    （1）在脚本中创建数据库连接（database link）bj_ysd_remote基表作为数据库基表，Bj_ysd_local代表本地数据库上的源基表。

     Creat database link remote(连接名)

     Connect to bj(帐户) indentified by bj(密码)

     Using ‘:2’;

    （2）复制记录

     create or replace trigger trig_ysd（触发器名）

     after insert on bj_ysd_local

     for each row

     begin

     insert into bj_ysd_remote@dblink remote

     value(:new.x1,:new.x2,……)/＊x1.x2代表字段名＊／

     end;

    （3）删除记录

      create or replace trigger trig_ysd_del

      after delete on bj_ysd_local

      for each row

      begin

          delete from bj_ysd_remote@dblink remote

      where x1=:old.x1

      end;

５．用数据库触发器完成瀑布式删除操作

    在某些情况下，当要删除一条记录时，该记录是与外键有关的另外一张基表上的记录时，这个删除操作必须在模型中进行传递，否则会出现大量的冗长数据，仍以cumstomer 和order基表为例，当从customer中删除一个客户时，order基表中所有相关记录也应当删除。

    Create or replace trigger trig_cust

    Before delete on  customer

    For each row

    Begin

        Delete from order；

        Where  cu_no=old.cu_no；

   End;

６．用触发器完成动态数据的操作

    在涉及如何实现动态库存的问题时，可用触发器解决。仓库有验收、出库、调拨、报废、退料、让售等这些数据必须与以前的库存相加减，才能完成动态库存操作。本文仅以验收单触发器为例，其它的结构雷同。它们涉及到两个基表：bi_ysd(验收单)，Bj_kcb(当前库存表)，前者的表结构（rq(日期)，ysdh(验收单号)， bjbm(备件编码)，yssl(验收数量)，ysdj(验收单价)），后者的表结构为（bjbm（备件编码）,dqkcl（当前库存量）,dqkcje（当前库存金额））触发器如下：

      create or replace trigger trig_ysd

      after insert or update or delete on bj_ysd

      for each row

      declare rq1 varchar2(8);rq2 varchar2(8);

      /*限于篇幅，yssl1,yssl2,ysdj1,ysdj2,bjbm1,bjbm2,ii声明略*/

      if inserting or updating then

          rq1:=:new.rq;bjbm1:=:new.bjbm;yssl1:=:new.yssl;

          ysdj1:=:new.ysdj;

select count(*) into ii from bj_dqkcb

where bjbm=bjbm1;

          if  ii=0 then

             insert  into  bj_dqkcb(bjbm,dqkcl,dqkcje)

             value(bjbm1,yssl1,ysdj1);

         else

             update bj_dqkcb

             set dqkcl=dqkcl+yssl1;

             dqkcje=dqkcje+yssl1*ysdj1;

         end if

      end if

      if deleting or updating then

         rq2:=:old.rq;bjbm2:=:old.bjbm;yssl2:=:old.yssl;

         ysdj2:=:old.ysdj;

         update bj_dqkcb

         set dqkcb=dqkcl-yssl2;

         dqkcje=dqkcje-yssl2*ysdj2

      end if;

     end ;

７．结束语

    数据库触发器在数据库开发、ＭＩＳ开发上有很广泛的应用，但经验表明，使用过多的触发器将降低整个数据库的性能。如果数据库触发器写得不好，它会很快破坏数据库的性能，因此，在适当的时候使用恰当的触发器显得非常重要。

参考文献：

Michael Abbey.机械工业出版社.Oracle8初学者指南,1998

Joline Morrison.机械工业出版社.Oracle8数据库指南,1999 

Tile:The applications of the oracle triggers in the development of MIS

Abstract:the paper introduces the concept and types of the oracle triggers,summarizes the applications of the oracle triggers in the MIS,and provides the examples for reference.

Key words:oracle   trigger

　　在svrmgrl下，用“oradebug ipc”，可看出ORACLE占用共享内存的分段和大小。

　　example:

　　SVRMGR> oradebug ipc

　　-------------- Shared memory --------------

　　Seg Id Address Size

　　1153 7fe000 784

　　1154 800000 419430400

　　1155 19800000 67108864

　　4. 如何查看当前SQL*PLUS用户的sid和serial#?

　　在SQL*PLUS下，运行:

　　“select sid, serial#, status from v$session

　　where audsid=userenv('sessionid');”

　　5. 如何查看当前数据库的字符集?

　　在SQL*PLUS下，运行:

　　“select userenv('language') from dual;”

　　或:

　　“select userenv('lang') from dual;”

　　6. 如何查看数据库中某用户，正在运行什么SQL语句?

　　根据MACHINE、USERNAME或SID、SERIAL#，连接表V$SESSION和V$SQLTEXT，可查出。

　　SQL*PLUS语句:

　　“SELECT SQL_TEXT FROM V$SQL_TEXT T, V$SESSION S WHERE T.ADDRESS=S.SQL_ADDRESS

　　AND T.HASH_VALUE=S.SQL_HASH_VALUE

　　AND S.MACHINE='XXXXX' OR USERNAME='XXXXX' -- 查看某主机名，或用户名

　　/”

　　7. 如何删除表中的重复记录?

　　例句:

　　DELETE

　　FROM table_name a

　　WHERE rowid > ( SELECT min(rowid)

　　FROM table_name b

　　WHERE b.pk_column_1 = a.pk_column_1

　　and b.pk_column_2 = a.pk_column_2 );

　　8. 手工临时强制改变服务器字符集

　　以sys或system登录系统，sql*plus运行:“create database character set us7ascii;".

　　有以下错误提示:

　　* create database character set US7ASCII

　　ERROR at line 1:

　　ORA-01031: insufficient privileges

　　实际上，看v$nls_parameters，字符集已更改成功。但重启数据库后，数据库字符集又变回原来的了。

　　该命令可用于临时的不同字符集服务器之间数据倒换之用。

　　9. 怎样查询每个instance分配的PCM锁的数目

　　用以下命令:

　　select count(*) "Number of hashed PCM locks" from v$lock_element where bitand(flags,4)<>0

　　/

　　select count(*) "Number of fine grain PCM locks" from v$lock_element

　　where bitand(flags,4)=0

　　/

　　10. 怎么判断当前正在使用何种SQL优化方式?

　　用explain plan产生EXPLAIN PLAN，检查PLAN_TABLE中ID=0的POSITION列的值。

　　e.g.

　　select decode(nvl(position,-1),-1,'RBO',1,'CBO') from plan_table where id=0

　　/

　　11. 做EXPORT时，能否将DUMP文件分成多个?

　　ORACLE8I中EXP增加了一个参数FILESIZE，可将一个文件分成多个:

　　EXP SCOTT/TIGER FILE=(ORDER_1.DMP,ORDER_2.DMP,ORDER_3.DMP) FILESIZE=1G TABLES=ORDER;

　　其他版本的ORACLE在UNIX下可利用管道和split分割:

　　mknod pipe p

　　split -b 2048m pipe order & #将文件分割成，每个2GB大小的，以order为前缀的文件:

　　#orderaa,orderab,orderac,... 并将该进程放在后台。

　　EXP SCOTT/TIGER FILE=pipe tables=order

导入导出命令：
备份：exp 用户/密码@服务名 file=testj.dmp
恢复：imp 用户/密码@服务名 file=testj.dmp full y
恢复之前先建表空间、用户（已有时先删掉用户再新建用户）

　　在本文中，我想演示如何从Oracle9i数据库直接发送电子邮件，作为一种实时通信解决方案。这样我们要监视存储过程就不再需要等待它们完成了，这样的方法还为开发者提供了其他的一些好处:

　　. 可以在几分钟内调试一些很长的批处理过程，而不需要等几个小时;

　　. 计算用于指定代码块所需的执行时间;

　　这就需要解决一个问题，我们如何从运行的存储过程中输出消息以便我们可以即时检查它们，即使我们不在办公场所?我们的做法是把所有必需的过程与函数包装在自定义的包中，然后使用Oracle9i UTL_SMTP包直接地从Oracle数据库中发送电子邮件。下面我将详细讲解一些这个过程。

　　Oracle的UTL_SMTP包

　　在Oracle9i中引入了UTL_SMTP包(SMTP代表Simple Mail Transfer Protocol简单邮件传送协议，使用TCP端口25在客户机和服务器之间建立通信联络)，使开发者能够从数据库发送电子邮件。

　　只有安装带有Java虚拟机(JVM)的8i或更高的版本才能使用UTL_SMTP。 此外还必须把plsql.jar载入数据库中。否则，当调用UTL_SMTP API来发送电子邮件的时候我们将得到下面的异常:ORA - 29540 : class oracle/plsql/net/TCPConnection does not exist。

　　默认的$ORACLE_HOME/javavm/install/initjvm.sql脚本(安装了JVM)不运行把plsql.jar载入数据库的initplsj.sql脚本。系统用户或者内部用户可以手工运行$ORACLE_HOME/RDBMS/ADMIN/initplsj.sql脚本以解决这个问题。 如果你没有可用的脚本，你要么可以从Oracle支持那里得到它，要么可以简单地直接使用loadjava载入实用程序plsql.jar:

　　loadjava -user sys/password@database -resolve plsql/jlib/plsql.jar

　　UTL_SMTP API:

　　本文的代码中使用了下列UTL_SMTP包中的API:

　　OPEN_CONNECTION():打开到简单邮件传送协议服务器的连接。

　　HELO():执行连接之后建立与简单邮件传送协议服务器初始的收发关系功能，它能识别发送到服务器的“信使”。

　　MAIL():初始化与服务器的邮件交换，但是事实上不发送消息。

　　RCPT():识别消息的接受者。为了把一条消息发送到多个接受者，你必须多次调用这个过程。

　　DATA():指定电子邮件的内容。

　　QUIT():终止一个SMTP会话并且断开与服务器的连接。

　　为了利用应用程序编程接口，把下面的调用按照给定的顺序放入程序中:

　　调用 OPEN_CONNECTION

　　调用 HELO

　　调用 MAIL

　　调用 RCPT for each recipient

　　格式化电子邮件的内容然后调用MAIL

　　调用 QUIT

　　EmailUtils包规范

　　EmailUtils包包括下列API:

　　SetSender/GetSender-设置/取得发送者

　　SetRecipient/GetRecipient -设置/取得接受者

　　SetCcrecipient/GetCcrecipient -设置/取得抄件接受者

　　SetMailHost/GetMailHost -设置/取得邮件主机

　　SetSubject/GetSubject -设置/取得主题

　　Send-发送邮件

　　代码1说明了EmailUtils包的规范:

　　create or replace package EmailUtils as

　　procedure SetSender(pSender in varchar2);

　　function GetSender

　　return varchar2;

　　procedure SetRecipient(pRecipient in varchar2);

　　function GetRecipient

　　return varchar2;

　　procedure SetCcRecipient(pCcRecipient in varchar2);

　　function GetCcRecipient

　　return varchar2;

　　procedure SetMailHost(pMailHost in varchar2);

　　function GetMailHost

　　return varchar2;

　　procedure SetSubject(pSubject in varchar2);

　　function GetSubject

　　return varchar2;

　　procedure Send(pMessage in varchar2);

　　procedure Send(pSender in varchar2,

　　pRecipient in varchar2,

　　pMailHost in varchar2,

　　pCcRecipient in varchar2 := null,

　　pSubject in varchar2 := null,

　　pMessage in varchar2 := null);

　　end EmailUtils;

　　/

　　可以看出，Send过程是重载过程:包规范中包括这个过程的两个版本。 一个版本当至少三个强制性参数要规定的时候引用，pSender，pRecipient和pMailHost:

　　procedure Send(pSender in varchar2,

　　pRecipient in varchar2,

　　pMailHost in varchar2,

　　pCcRecipient in varchar2 := null,

　　pSubject in varchar2 := null,

　　pMessage in varchar2 := null);
 

　　另一个版本只有当提供pMessage参数值时执行:

　　procedure Send(pMessage in varchar2);

　　第二个版本是用作调试的版本。 所有的电子邮件消息共用同样的发送者、接受者、邮件主机、抄送接受者和主题信息，这些都是我在会话的开始的时候设置好的。 下面是一个PL/SQL程序块的例子:

　　begin

　　EmailUtils.SetSender('WayneZ@MyCompany.com');

　　EmailUtils.SetRecipient('waynezheng@vip.sina.com');

　　EmailUtils.SetCcRecipient('WayneZ@MyCompany.com');

　　EmailUtils.SetMailHost('MyServer.MyCompany.com');

　　EmailUtils.SetSubject('DeleteClassifications procedure: Run 1');

　　end;

　　/

　　一个实际的电子邮件消息将在每个Send过程调用中被指定。 我们可以把所用的EmailUtils.Send()调用插入到我们调试的代码中，我们以前为了得到同样的调试结果使用的是DBMS_OUTPUT.PUT_LINE()调用。:

　　vMessage := 'Point 1.' || utl_tcp.crlf ||

　　'Rows processed: ' || to_char(vRows) || utl_tcp.crlf ||

　　'Elapsed time: ' || vTime;

　　EmailUtils.Send(vMessage);

　　vMessage := 'Point 3.' || utl_tcp.crlf ||

　　'Rows processed: ' || to_char(vRows) || utl_tcp.crlf ||

　　'Elapsed time: ' || vTime;

　　EmailUtils.Send(vMessage);

　　代码2显示带有重载Send过程的EmailUtils规格。 我们可以看到，Send过程的代码相当简单。 UTL_SMTP包不提供用于格式化消息内容的应用编程接口。 而是由用户负责格式化消息。 这就是为什么下列程序块要被包含到每个Send过程中以便格式化电子邮件的头部。

　　vMessage := 'Date: ' ||

　　to_char(sysdate, 'fmDy, DD Mon YYYY fxHH24:MI:SS') ||

　　utl_tcp.crlf ||

　　'From: ' || pSender || utl_tcp.crlf ||

　　'Subject: ' || pSubject || utl_tcp.crlf ||

　　'To: ' || pRecipient || utl_tcp.crlf;

　　同时,如果消息长度超过2000字符的话，你可能得到一个错误( ORA - 06502 : PL/SQL : numeric or value error)。 所以为了避免出现这个错误，我们使用下面的程序块,不允许消息超过2000个字符:

　　if length(vMessage) > 2000

　　then

　　vMessage := substr(vMessage, 1, 2000);

　　end if;

　　如果需要发送带有超过2000字的电子邮件，那么可以使用另三个UTL_SMTP应用程序编程接口，提供比DATA()过程更加精细的控制。 首先, OPEN_DATA()发送数据命令。 然后WRITE_DATA()添加数据到你要发送的字符串中。 你可以调用WRITE_DATA()任意多次，这样你就可以一次写2000个字符以克服字数的限制。 最后, CLOSE_DATA()通过发送一个封装在CRLF中的终止周期结束电子邮件消息。

　　实时消息使你的生活更加舒适

　　从数据库发送电子邮件就是那么容易。 一旦你试用这个简单的操作，我相信你会发现它很有用，便于你的数据库操作,例如调试、远程的数据库监控和输出数据库数据。

　　每个数据库开发者都有在代码中使用大量的DBMS_OUTPUT调用的调试经历。 在开始一个SQL * Plus会话之后,输入SET SERVEROUTPUT ON然后运行这个过程。 放进DBMS_OUTPUT.PUT_LINE调用的消息显示在屏幕上--但是只有在过程完成以后才能显示出来。 这个过程极端地麻烦，尤其在调试长的批处理时通常是要运行整晚。 你可以等待10到12小时仅仅是为了查出错误的代码，然后修改，再去等待下一个10到12个小时? 然而，如果你有访问消息的实时的办法，那么你可以在头5到10分钟内捕捉到问题。

　　DBMS_OUTPUT包也有其他的缺点。 例如,它不接受可变的布尔类型以及它有255字符每行的限制(如果你想输出一个长的消息的话，那么你会得到这个异常:ORA - 20000 : ORU - 10028 : line length overflow, limit of 255 bytes per line)。 把它的缺点全部列出这已经超出本文的范围了，但是重要结论就是DBMS_OUTPUT包不许数据库开发者实时的看到消息。

　　谈到服务器上的OS文件，你会不会喜欢把选定的数据从服务器中输出到一个Excel电子表格呢? 一个办法就是使用Oracle的UTL_FILE包,它提供了一个标准OS流文档输入/输出的限制级版本。 然而, PL/SQL程序只能访问在初始化文件INIT.ORA的UTL_FILE_DIR参数规定的目录。 这个参数大多数情况下是空的。为了使这个目录可用来进行文件访问，必须请数据库管理者修改初始化文件。 这有些麻烦。使用EmailUtils包,你可以简简单单的把数据写入一个电子邮件中，发送给自己，然后收到它的副本粘贴到自己喜欢的文档编辑器中。

　　假设当前执行命令为:select * from tab;

　　(a)ppend　　　　 添加文本到缓冲区当前行尾　　　　a order by tname　结果:select * from tab order by tname;

　　(注:a后面跟2个空格)

　　(c)hange/old/new 在当前行用新的文本替换旧的文本　c/*/tname　　　　　结果:select tname from tab;

　　(c)hange/text　　从当前行删除文本　　　　　　　　c/tab　　　　　　　结果:select tname from ;

　　del　　　　　　　删除当前行

　　del n　　　　　　删除第n行

　　(i)nput 文本　　 在当前行之后添加一行

　　(l)ist　　　　　 显示缓冲区中所有行

　　(l)ist n　　　　 显示缓冲区中第 n 行

　　(l)ist m n　　　 显示缓冲区中 m 到 n 行

　　run　　　　　　　执行当前缓冲区的命令

　　/　　　　　　　　执行当前缓冲区的命令

　　r　　　　　　　　执行当前缓冲区的命令

　　@文件名　　　　　运行调入内存的sql文件，如:

　　SQL> edit s<回车>

　　如果当前目录下不存在s.sql文件，则系统自动生成s.sql文件，

　　在其中输入“select * from tab;”，存盘退出。

　　SQL> @s<回车>

　　系统会自动查询当前用户下的所有表、视图、同义词。

　　@@文件名　　　　 在.sql文件中调用令一个.sql文件时使用

　　save 文件名　　　将缓冲区的命令以文件方式存盘，缺省文件扩展名为.sql

　　get 文件名　　　 调入存盘的sql文件

　　start 文件名　　 运行调入内存的sql文件

　　spool 文件名　　 把这之后的各种操作及执行结果“假脱机”即存盘到磁盘文件上，默认文件扩展名为.lst

　　spool　　　　　　显示当前的“假脱机”状态

　　spool off　　　　停止输出

　　例:

　　SQL> spool a

　　SQL> spool

　　正假脱机到 A.LST

　　SQL> spool off

　　SQL> spool

　　当前无假脱机

　　exit　　　　　　 退出SQL*PLUS

　　desc 表名　　　　显示表的结构

　　show user　　　　显示当前连接用户

　　show error　　　 显示错误

　　show all　　　　 显示所有68个系统变量值

　　edit　　　　　　 打开默认编辑器，Windows系统中默认是notepad.exe，把缓冲区中最后一条SQL语句调入afiedt.buf文件中进行编辑

　　edit 文件名　　　把当前目录中指定的.sql文件调入编辑器进行编辑

　　clear screen　　 清空当前屏幕显示

　　select t.tablespace_name, round(sum(bytes/(1024*1024)),0) ts_size

　　from dba_tablespaces t, dba_data_files d

　　where t.tablespace_name = d.tablespace_name

　　group by t.tablespace_name;

　　2、查看表空间物理文件的名称及大小

　　select tablespace_name, file_id, file_name,

　　round(bytes/(1024*1024),0) total_space

　　from dba_data_files

　　order by tablespace_name;

　　3、查看回滚段名称及大小

　　select segment_name, tablespace_name, r.status,

　　(initial_extent/1024) InitialExtent,(next_extent/1024) NextExtent,

　　max_extents, v.curext CurExtent

　　From dba_rollback_segs r, v$rollstat v

　　Where r.segment_id = v.usn(+)

　　order by segment_name ;

　　4、查看控制文件

　　select name from v$controlfile;

　　5、查看日志文件

　　select member from v$logfile;

　　6、查看表空间的使用情况

　　select sum(bytes)/(1024*1024) as free_space,tablespace_name

　　from dba_free_space

　　group by tablespace_name;

　　SELECT A.TABLESPACE_NAME,A.BYTES TOTAL,B.BYTES USED, C.BYTES FREE,

　　(B.BYTES*100)/A.BYTES "% USED",(C.BYTES*100)/A.BYTES "% FREE"

　　FROM SYS.SM$TS_AVAIL A,SYS.SM$TS_USED B,SYS.SM$TS_FREE C

　　WHERE A.TABLESPACE_NAME=B.TABLESPACE_NAME AND A.TABLESPACE_NAME=C.TABLESPACE_NAME;

　　7、查看数据库库对象

　　select owner, object_type, status, count(*) count# from all_objects group by owner, object_type, status;

　　8、查看数据库的版本

　　Select version FROM Product_component_version

　　Where SUBSTR(PRODUCT,1,6)='Oracle';

　　9、查看数据库的创建日期和归档方式

　　Select Created, Log_Mode, Log_Mode From V$Database;

　　10、捕捉运行很久的SQL

　　column username format a12

　　column opname format a16

　　column progress format a8

　　select username,sid,opname,

　　round(sofar*100 / totalwork,0) || '%' as progress,

　　time_remaining,sql_text

　　from v$session_longops , v$sql

　　where time_remaining <> 0

　　and sql_address = address

　　and sql_hash_value = hash_value

　　/

　　11、查看数据表的参数信息

　　SELECT partition_name, high_value, high_value_length, tablespace_name,

　　pct_free, pct_used, ini_trans, max_trans, initial_extent,

　　next_extent, min_extent, max_extent, pct_increase, FREELISTS,

　　freelist_groups, LOGGING, BUFFER_POOL, num_rows, blocks,

　　empty_blocks, avg_space, chain_cnt, avg_row_len, sample_size,

　　last_analyzed

　　FROM dba_tab_partitions

　　--WHERE table_name = :tname AND table_owner = :towner

　　ORDER BY partition_position

　　12、查看还没提交的事务

　　select * from v$locked_object;

　　select * from v$transaction;

　　13、查找object为哪些进程所用

　　select

　　p.spid,

　　s.sid,

　　s.serial# serial_num,

　　s.username user_name,

　　a.type object_type,

　　s.osuser os_user_name,

　　a.owner,

　　a.object object_name,

　　decode(sign(48 - command),

　　1,

　　to_char(command), 'Action Code #' || to_char(command) ) action,

　　p.program oracle_process,

　　s.terminal terminal,

　　s.program program,

　　s.status session_status

　　from v$session s, v$access a, v$process p

　　where s.paddr = p.addr and

　　s.type = 'USER' and

　　a.sid = s.sid and

　　a.object='SUBSCRIBER_ATTR'

　　order by s.username, s.osuser

 

　　 单行函数

　　 组函数

　　本文将讨论如何利用单行函数以及使用规则。

　　SQL中的单行函数

　　SQL和PL/SQL中自带很多类型的函数，有字符、数字、日期、转换、和混合型等多种函数用于处理单行数据，因此这些都可被统称为单行函数。这些函数均可用于SELECT,WHERE、ORDER BY等子句中，例如下面的例子中就包含了TO_CHAR,UPPER,SOUNDEX等单行函数。
SELECT ename,TO_CHAR(hiredate,'day,DD-Mon-YYYY')FROM empWhere UPPER(ename) Like 'AL%'ORDER BY SOUNDEX(ename)

　　单行函数也可以在其他语句中使用，如update的SET子句，INSERT的VALUES子句，DELET的WHERE子句,认证考试特别注意在SELECT语句中使用这些函数，所以我们的注意力也集中在SELECT语句中。

　　NULL和单行函数

　　在如何理解NULL上开始是很困难的，就算是一个很有经验的人依然对此感到困惑。NULL值表示一个未知数据或者一个空值，算术操作符的任何一个操作数为NULL值，结果均为提个NULL值,这个规则也适合很多函数，只有CONCAT,DECODE,DUMP,NVL,REPLACE在调用了NULL参数时能够返回非NULL值。在这些中NVL函数时最重要的，因为他能直接处理NULL值，NVL有两个参数：NVL(x1,x2),x1和x2都式表达式，当x1为null时返回X2,否则返回x1。

　　下面我们看看emp数据表它包含了薪水、奖金两项，需要计算总的补偿
column name emp_id salary bonuskey type pk nulls/unique nn,u nnfk table datatype number number numberlength 11.2 11.2

　　不是简单的将薪水和奖金加起来就可以了，如果某一行是null值那么结果就将是null，比如下面的例子：
update empset salary=(salary+bonus)*1.1

　　这个语句中，雇员的工资和奖金都将更新为一个新的值，但是如果没有奖金，即 salary + null,那么就会得出错误的结论，这个时候就要使用nvl函数来排除null值的影响。
所以正确的语句是：
update empset salary=(salary+nvl(bonus,0)*1.1
单行字符串函数

　　单行字符串函数用于操作字符串数据，他们大多数有一个或多个参数，其中绝大多数返回字符串

　　ASCII()
　　c1是一字符串，返回c1第一个字母的ASCII码，他的逆函数是CHR()
SELECT ASCII('A') BIG_A,ASCII('z') BIG_z FROM empBIG_A BIG_z65 122

　　CHR(＜i＞)[NCHAR_CS]
　　i是一个数字，函数返回十进制表示的字符
select CHR(65),CHR(122),CHR(223) FROM empCHR65 CHR122 CHR223A z B

　　CONCAT(,)
　　c1,c2均为字符串，函数将c2连接到c1的后面，如果c1为null,将返回c2.如果c2为null,则返回c1，如果c1、c2都为null，则返回null。他和操作符||返回的结果相同
select concat('slobo ','Svoboda') username from dualusernameslobo Syoboda

　　INITCAP()
　　c1为一字符串。函数将每个单词的第一个字母大写其它字母小写返回。单词由空格，控制字符，标点符号限制。
select INITCAP('veni,vedi,vici') Ceasar from dualCeasarVeni,Vedi,Vici

　　INSTR(,[,＜i＞[,]])
　　c1,c2均为字符串，i,j为整数。函数返回c2在c1中第j次出现的位置，搜索从c1的第i个字符开始。当没有发现需要的字符时返回0,如果i为负数，那么搜索将从右到左进行，但是位置的计算还是从左到右，i和j的缺省值为1.
select INSTR('Mississippi','i',3,3) from dualINSTR('MISSISSIPPI','I',3,3)11select INSTR('Mississippi','i',-2,3) from dualINSTR('MISSISSIPPI','I',3,3)2

　　INSTRB(,[,i[,j])
　　与INSTR（）函数一样，只是他返回的是字节，对于单字节INSTRB()等于INSTR()

　　LENGTH()
　　c1为字符串，返回c1的长度，如果c1为null，那么将返回null值。
select LENGTH('Ipso Facto') ergo from dualergo10

　　LENGTHb()
　　与LENGTH()一样，返回字节。

　　lower()
　　返回c的小写字符，经常出现在where子串中
select LOWER(colorname) from itemdetail WHERE LOWER(colorname) LIKE '%white%'COLORNAMEWinterwhite

　　LPAD(,＜i＞[,])
　　c1,c2均为字符串，i为整数。在c1的左侧用c2字符串补足致长度i,可多次重复，如果i小于c1的长度，那么只返回i那么长的c1字符，其他的将被截去。c2的缺省值为单空格，参见RPAD。
select LPAD(answer,7,'') padded,answer unpadded from question;PADDED UNPADDED Yes YesNO NOMaybe maybe

　　LTRIM(,)
　　把c1中最左边的字符去掉，使其第一个字符不在c2中，如果没有c2，那么c1就不会改变。
select LTRIM('Mississippi','Mis') from dualLTRppi

　　RPAD(,＜i＞[,])
　　在c1的右侧用c2字符串补足致长度i,可多次重复，如果i小于c1的长度，那么只返回i那么长的c1字符，其他的将被截去。c2的缺省值为单空格,其他与LPAD相似

　　RTRIM(,)
　　把c1中最右边的字符去掉，使其第后一个字符不在c2中，如果没有c2，那么c1就不会改变。

　　REPLACE(,[,])
　　c1,c2,c3都是字符串，函数用c3代替出现在c1中的c2后返回。
select REPLACE('uptown','up','down') from dualREPLACEdowntown

　　STBSTR(,＜i＞[,])
　　c1为一字符串，i,j为整数，从c1的第i位开始返回长度为j的子字符串，如果j为空，则直到串的尾部。
select SUBSTR('Message',1,4) from dualSUBSMess

　　SUBSTRB(,＜i＞[,])
　　与SUBSTR大致相同，只是I,J是以字节计算。

　　SOUNDEX()
　　返回与c1发音相似的词
select SOUNDEX('dawes') Dawes SOUNDEX('daws') Daws, SOUNDEX('dawson') from dualDawes Daws DawsonD200 D200 D250

　　TRANSLATE(,,)
　　将c1中与c2相同的字符以c3代替
select TRANSLATE('fumble','uf','ar') test from dualTEXTramble

　　TRIM([[]] from c3)
　　将c3串中的第一个，最后一个，或者都删除。
select TRIM(' space padded ') trim from dual TRIMspace padded

　　UPPER()
　　返回c1的大写，常出现where子串中
select name from dual where UPPER(name) LIKE 'KI%'NAMEKING
单行数字函数

　　单行数字函数操作数字数据，执行数学和算术运算。所有函数都有数字参数并返回数字值。所有三角函数的操作
数和值都是弧度而不是角度，oracle没有提供内建的弧度和角度的转换函数。

　　ABS()
　　返回n的绝对值

　　ACOS()
　　反余玄函数，返回-1到1之间的数。n表示弧度
select ACOS(-1) pi,ACOS(1) ZERO FROM dualPI ZERO3.14159265 0

　　ASIN()
　　反正玄函数，返回-1到1，n表示弧度

　　ATAN()
　　反正切函数，返回n的反正切值，n表示弧度。

　　CEIL()
　　返回大于或等于n的最小整数。

　　COS()
　　返回n的余玄值，n为弧度

　　COSH()
　　返回n的双曲余玄值，n 为数字。
select COSH(<1.4>) FROM dualCOSH(1.4)2.15089847

　　EXP()
　　返回e的n次幂，e=2.71828183.

　　FLOOR()
　　返回小于等于N的最大整数。

　　LN()
　　返回N的自然对数，N必须大于0

　　LOG(,)
　　返回以n1为底n2的对数

　　MOD()
　　返回n1除以n2的余数，

　　POWER(,)
　　返回n1的n2次方

　　ROUND(,)
　　返回舍入小数点右边n2位的n1的值，n2的缺省值为0，这回将小数点最接近的整数，如果n2为负数就舍入到小数点左边相应的位上，n2必须是整数。
select ROUND(12345,-2),ROUND(12345.54321,2) FROM dualROUND(12345,-2) ROUND(12345.54321,2)12300 12345.54

　　SIGN()
　　如果n为负数，返回-1,如果n为正数，返回1，如果n=0返回0.

　　SIN（)
　　返回n的正玄值,n为弧度。

　　SINH()
　　返回n的双曲正玄值,n为弧度。

　　SQRT()
　　返回n的平方根,n为弧度

　　TAN（)
　　返回n的正切值,n为弧度

　　TANH()
　　返回n的双曲正切值,n为弧度

　　TRUNC(,)
　　返回截尾到n2位小数的n1的值，n2缺省设置为0，当n2为缺省设置时会将n1截尾为整数，如果n2为负值，就截尾在小数点左边相应的位上。

　　单行日期函数

　　单行日期函数操作DATA数据类型，绝大多数都有DATA数据类型的参数，绝大多数返回的也是DATA数据类型的值。

　　ADD_MONTHS(,＜i＞)
　　返回日期d加上i个月后的结果。i可以使任意整数。如果i是一个小数，那么数据库将隐式的他转换成整数，将会截去小数点后面的部分。

　　LAST_DAY()
　　函数返回包含日期d的月份的最后一天

　　MONTHS_BETWEEN(,)
　　返回d1和d2之间月的数目,如果d1和d2的日的日期都相同，或者都使该月的最后一天，那么将返回一个整数，否则会返回的结果将包含一个分数。

　　NEW_TIME(,,)
　　d1是一个日期数据类型，当时区tz1中的日期和时间是d时，返回时区tz2中的日期和时间。tz1和tz2时字符串。

　　NEXT_DAY(,)
　　返回日期d后由dow给出的条件的第一天，dow使用当前会话中给出的语言指定了一周中的某一天，返回的时间分量与d的时间分量相同。
select NEXT_DAY('01-Jan-2000','Monday') "1st Monday",NEXT_DAY('01-Nov-2004','Tuesday')+7 "2nd Tuesday") from dual;1st Monday 2nd Tuesday03-Jan-2000 09-Nov-2004

　　ROUND([,])
　　将日期d按照fmt指定的格式舍入，fmt为字符串。

　　SYADATE
　　函数没有参数，返回当前日期和时间。

　　TRUNC([,])
　　返回由fmt指定的单位的日期d.
单行转换函数

　　单行转换函数用于操作多数据类型，在数据类型之间进行转换。

　　CHARTORWID()
　　c 使一个字符串，函数将c转换为RWID数据类型。
SELECT test_id from test_case where rowid=CHARTORWID('AAAA0SAACAAAALiAAA')

　　CONVERT(,[,])
　　c尾字符串，dset、sset是两个字符集，函数将字符串c由sset字符集转换为dset字符集，sset的缺省设置为数据库的字符集。

　　HEXTORAW()
　　x为16进制的字符串，函数将16进制的x转换为RAW数据类型。

　　RAWTOHEX()
　　x是RAW数据类型字符串，函数将RAW数据类转换为16进制的数据类型。

　　ROWIDTOCHAR()
　　函数将ROWID数据类型转换为CHAR数据类型。

　　TO_CHAR([[,)
　　x是一个data或number数据类型，函数将x转换成fmt指定格式的char数据类型，如果x为日期nlsparm=NLS_DATE_LANGUAGE 控制返回的月份和日份所使用的语言。如果x为数字nlsparm=NLS_NUMERIC_CHARACTERS 用来指定小数位和千分位的分隔符，以及货币符号。
NLS_NUMERIC_CHARACTERS ="dg", NLS_CURRENCY="string"

　　TO_DATE([,[,）
　　c表示字符串，fmt表示一种特殊格式的字符串。返回按照fmt格式显示的c,nlsparm表示使用的语言。函数将字符串c转换成date数据类型。

　　TO_MULTI_BYTE()
　　c表示一个字符串，函数将c的担子截字符转换成多字节字符。

　　TO_NUMBER([,[,)
　　c表示字符串，fmt表示一个特殊格式的字符串，函数返回值按照fmt指定的格式显示。nlsparm表示语言，函数将返回c代表的数字。

　　TO_SINGLE_BYTE()
　　将字符串c中得多字节字符转化成等价的单字节字符。该函数仅当数据库字符集同时包含单字节和多字节字符时才使用

　　其它单行函数

　　BFILENAME(
,)
　　dir是一个directory类型的对象，file为一文件名。函数返回一个空的BFILE位置值指示符，函数用于初始化BFILE变量或者是BFILE列。

　　DECODE(,,[,,,[])
　　x是一个表达式，m1是一个匹配表达式，x与m1比较，如果m1等于x，那么返回r1,否则,x与m2比较，依次类推m3,m4,m5....直到有返回结果。

　　DUMP(,[,[,[,]]])
　　x是一个表达式或字符，fmt表示8进制、10进制、16进制、或则单字符。函数返回包含了有关x的内部表示信息的VARCHAR2类型的值。如果指定了n1,n2那么从n1开始的长度为n2的字节将被返回。

　　EMPTY_BLOB()
　　该函数没有参数，函数返回 一个空的BLOB位置指示符。函数用于初始化一个BLOB变量或BLOB列。

　　EMPTY_CLOB()
　　该函数没有参数，函数返回 一个空的CLOB位置指示符。函数用于初始化一个CLOB变量或CLOB列。

　　GREATEST()
　　exp_list是一列表达式，返回其中最大的表达式，每个表达式都被隐含的转换第一个表达式的数据类型，如果第一个表达式是字符串数据类型中的任何一个，那么返回的结果是varchar2数据类型，同时使用的比较是非填充空格类型的比较。

　　LEAST()
　　exp_list是一列表达式，返回其中最小的表达式，每个表达式都被隐含的转换第一个表达式的数据类型，如果第一个表达式是字符串数据类型中的任何一个，将返回的结果是varchar2数据类型，同时使用的比较是非填充空格类型的比较。

　　UID
　　该函数没有参数，返回唯一标示当前数据库用户的整数。

　　USER
　　返回当前用户的用户名

　　USERENV()
　　基于opt返回包含当前会话信息。opt的可选值为：

　　ISDBA　 　　会话中SYSDBA脚色响应，返回TRUE
　　SESSIONID 　返回审计会话标示符
　　ENTRYID 　　返回可用的审计项标示符
　　INSTANCE　　在会话连接后，返回实例标示符。该值只用于运行Parallel 服务器并且有 多个实例的情况下使用。
　　LANGUAGE　　返回语言、地域、数据库设置的字符集。
　　LANG　　　　返回语言名称的ISO缩写。
　　TERMINAL　　为当前会话使用的终端或计算机返回操作系统的标示符。

　　VSIZE()
　　x是一个表达式。返回x内部表示的字节数。
SQL中的组函数

　　组函数也叫集合函数，返回基于多个行的单一结果，行的准确数量无法确定，除非查询被执行并且所有的结果都被包含在内。与单行函数不同的是，在解析时所有的行都是已知的。由于这种差别使组函数与单行函数有在要求和行为上有微小的差异.

　　组（多行）函数

　　与单行函数相比，oracle提供了丰富的基于组的，多行的函数。这些函数可以在select或select的having子句中使用，当用于select子串时常常都和GROUP BY一起使用。

　　AVG([{DISYINCT|ALL}])
　　返回数值的平均值。缺省设置为ALL.
SELECT AVG(sal),AVG(ALL sal),AVG(DISTINCT sal) FROM scott.empAVG(SAL) AVG(ALL SAL) AVG(DISTINCT SAL)1877.94118 1877.94118 1916.071413

　　COUNT({*|DISTINCT|ALL} )
　　返回查询中行的数目，缺省设置是ALL,*表示返回所有的行。

　　MAX([{DISTINCT|ALL}])
　　返回选择列表项目的最大值，如果x是字符串数据类型，他返回一个VARCHAR2数据类型，如果X是一个DATA数据类型，返回一个日期，如果X是numeric数据类型，返回一个数字。注意distinct和all不起作用，应为最大值与这两种设置是相同的。

　　MIN([{DISTINCT|ALL}])
　　返回选择列表项目的最小值。

　　STDDEV([{DISTINCT|ALL}])
　　返回选者的列表项目的标准差，所谓标准差是方差的平方根。

　　SUM([{DISTINCT|ALL}])
　　返回选择列表项目的数值的总和。

　　VARIANCE([{DISTINCT|ALL}])
　　返回选择列表项目的统计方差。

　　用GROUP BY给数据分组

　　正如题目暗示的那样组函数就是操作那些已经分好组的数据，我们告诉数据库用GROUP BY怎样给数据分组或者分类，当我们在SELECT语句的SELECT子句中使用组函数时，我们必须把为分组或非常数列放置在GROUP BY子句中，如果没有用group by进行专门处理，那么缺省的分类是将整个结果设为一类。
select stat,counter(*) zip_count from zip_codes GROUP BY state;ST ZIP_COUNT-- ---------AK 360AL 1212AR 1309AZ 768CA 3982

　　在这个例子中，我们用state字段分类；如果我们要将结果按照zip_codes排序,可以用ORDER BY语句，ORDER BY子句可以使用列或组函数。
select stat,counter(*) zip_count from zip_codes GROUP BY state ORDER BY COUNT(*) DESC;ST COUNT(*)-- --------NY 4312PA 4297TX 4123CA 3982

　　用HAVING子句限制分组数据

　　现在你已经知道了在查询的SELECT语句和ORDER BY子句中使用主函数，组函数只能用于两个子串中，组函数不能用于WHERE子串中，例如下面的查询是错误的：
错误SELECT sales_clerk,SUN(sale_amount) FROM gross_sales WHERE sales_dept='OUTSIDE' AND SUM(sale_amount)>10000 GROUP BY sales_clerk

　　这个语句中数据库不知道SUM()是什么，当我们需要指示数据库对行分组，然后限制分组后的行的输出时，正确的方法是使用HAVING语句：
SELECT sales_clerk,SUN(sale_amount) FROM gross_sales WHERE sales_dept='OUTSIDE' GROUP BY sales_clerkHAVING SUM(sale_amount)>10000;

　　嵌套函数

　　函数可以嵌套。一个函数的输出可以是另一个函数的输入。操作数有一个可继承的执行过程。但函数的优先权只是基于位置，函数遵循由内到外，由左到右的原则。嵌套技术一般用于象DECODE这样的能被用于逻辑判断语句IF....THEN...ELSE的函数。

ORACLE常用傻瓜問題1000問(之三)

ORACLE常用傻瓜問題1000問(之二)

Uwe Weber
Informix 和 DB2 UDB 的 IT 专家, IBM Germany

简介
在现代企业环境中，用多个数据库和多种品牌的数据库来存储公司数据已经不足为奇。最终，这些数据将会在不同数据库外进行比较、合并。

如果您有一个异构的数据库环境，并且计划将不同数据库中的数据收集到一个单独的应用程序中，那么您就应该可以使用传统技术执行该任务。在使用 Java 时，您将通过 JDBC 处理所有的数据库操作。清单 1 展示了在 Java 应用程序中如何连接 DB2 UDB 和 IDS 的代码片断。

清单 1. 使用 JDBC 建立到不同数据库的连接

1 try { // load JDBC drivers 2 Class.forName (JDBC_DRIVER_DB2); 3 Class.forName (JDBC_DRIVER_IDS); 4 } 5 catch (Exception e) { 6 // error handling 7 } 8 9 try { // establish connection and proceed with operation 10 con_db2 = DriverManager.getConnection (DBURL_DB2); 11 con_ids = Drivermanager.getConnection (DBURL_IDS); 12 13 Statement stmt_db2 = con_db2.createStatement (); 14 Statement stmt_ids = con_ids.createStatement (); 15 16 ResultSet rs_db2 = stmt_db2.executeQuery (SQL); 17 ResultSet rs_ids = stmt_ids.executeQuery (SQL); 18 19 // do something very important with the result sets... 20 } 21 catch (SQLException e) { 22 // error handling 23 }

两阶段提交协议简介
清单 1 中的演示允许您修改不同数据库中的数据。代替执行查询，它可以使用 JDBC 方法 executeUpdate() 执行数据修改。

但是如果您需要在单个事务中封装到 DB2 和 IDS 表的新一行的 insert，要做什么呢？
意思就是说，如果其中一条 insert 语句失败了，就应该将数据库（这里：两种数据库！）的初始状态恢复为客户机未执行任何动作的状态。该行为可以通过使用两阶段提交（Two-Phase-Commit）协议完成。这一标准化协议描述了如何实现分布式事务（XA）或分布式工作单元（Distributed Unit of Work，DUOW）的技术，以达到跨数据库系统的一致状态（根据 ACID）。

常规事务（单阶段提交）中，由 COMMIT 或 ROLLBACK 所执行的事务终止是一种决定性的操作，与之相反，两阶段提交（Two-Phase-Commit）事务是分为两步（阶段）进行的。

首先，两阶段提交（Two-Phase-Commit）事务的启动与常规的单阶段提交（One-Phase-Commit）事务类似。接着，应用程序/客户机对该两阶段提交（Two-Phase-Commit）操作中所涉及的所有数据库执行其修改工作。现在，在最终提交该事务之前，客户机通知参与的数据库准备提交（第 1 阶段）。如果客户机从数据库收到一条“okay”，就发出命令向数据库提交该事务（第 2 阶段）。最后分布式事务（Distributed Transaction）结束。

两阶段提交（Two-Phase-Commit）中的第 1 阶段十分重要。通过首先询问数据库是否可以进行提交，一旦某一参与的数据库报告错误，就有机会立即中止整个事务。因而，第 2 阶段将由 ROLLBACK，而非 COMMIT 完成。

图 1 提供了对于两阶段提交（Two-Phase-Commit）协议如何工作的图形化印象。正如所演示的，分布式事务（Distributed Transaction）使用由元组表示的描述符（例如：[x,b1]）。其意思是，一个分布式事务（Distributed Transaction）包含两个元素。首先，有一个惟一全局事务 ID（global transaction id） —— 代表分布式事务（Distributed Transaction）的简单标识符 - 由 x 表示，第二个是分支 ID（branch id），它描述整个事务的一部分。一般，分支指的是一个数据库连接。如果您有一个将处理两个参与数据库的分布式事务（Distributed Transaction），您就可以用诸如 [100,1] 的描述符表示一个数据库，用诸如 [100,2] 的描述符表示另一数据库。因此本例中，就有一个编号为 100 的全局事务，其中包含两个 ID 分别为 1 和 2 的分支。

“但是”，您或许会问，“如果在两阶段提交（Two-Phase-Commit）协议的第 2 阶段中出现错误，又将发生什么事情呢？”
“的确，您将陷入麻烦中！”
实际上，稍后我们将会讨论该主题。

图 1. 两阶段提交中的时间线和应用程序流

请看 清单 2。在第 16-19 行代码中，您可能错觉地认为第 17 和 18 行的语句都是属于由 con_db2.setAutoCommit(false)（第 16 行）所定义的事务边界的一部分。而事实却是该行代码启动了一个显式事务，用于连接到由 con_db2.commit()（第 19 行）所提交的 DB2 数据库。第 18 行中所做的修改不受该事务的影响。本例没有使用两阶段提交（Two-Phase-Commit）协议，因此，它不是一个分布式事务（Distributed Transaction）。无论是到 DB2 数据库的连接，还是到 Informix Dynamic Server（IDS）的连接，它们都没有意识到彼此的存在。

清单 2. 非“两阶段提交”的应用程序

1 try { 2 Class.forName (JDBC_DRIVER_DB2); 3 Class.forName (JDBC_DRIVER_IDS); 4 } 5 catch (Exception e) { 6 // error handling 7 } 8 9 try { 10 con_db2 = DriverManager.getConnection (DBURL_DB2); 11 con_ids = Drivermanager.getConnection (DBURL_IDS); 12 13 Statement stmt_db2 = con_db2.createStatement (); 14 Statement stmt_ids = con_ids.createStatement (); 15 16 con_db2.setAutoCommit (false); 17 stmt_db2.executeUpdate (SQL); 18 stmt_ids.executeUpdate (SQL); 19 con_db2.commit (); 20 21 // further processing 22 } 23 catch (SQLException e) { 24 // error handling 25 }

JTA 和事务管理器（TM）
Java Transaction API 允许您操作应用程序中的分布式事务（Distributed Transaction）。JTA 中有一组方法，它将传统的 JDBC 调用封装到了两阶段提交（Two-Phase-Commit）协议中。

在异构环境中，您通常会发现一个事务管理器（Transaction Manager），负责处理分布式事务。（实际上，事务管理器可以完成大量的工作负载平衡。）因此，不仅存在到数据库的直接连接，还有到事务管理器（Transaction Manager）的连接。这就是 JTA 发挥作用的地方：JTA 是 Java 应用程序和事务管理器（Transaction Manager）之间的接口。图 2 演示了一个包含分布式事务的典型环境。

由于存在事务管理器（Transaction Manager），它通常包含在应用程序服务器（Application Server）中，就不再有两层（Two-Tier）架构。传统的客户/服务器（Client/Server）架构已经由三层（Tree-Tier）架构所取代，三层架构包含应用程序/客户机、事务管理器（Transaction Manager）/应用程序服务器（Application Server）和数据库服务器，而数据库服务器一般称作 XA Resource。

图 2. 三层架构

1. 包含 SQL 和 JTA 调用的 Java 应用程序。
2. 管理分布式事务的应用程序服务器（Application Server）。
3. 参与分布式事务的数据库。
4. Java 应用程序向应用程序服务器（Application Server）提交常规 SQL 语句和通用的 XA 调用。
5. 应用程序所发送的消息由应用程序服务器（Application Server）进行处理，并使用 SQL 和数据库供应商特定的 XA 调用发送给数据库。

通常，应用程序服务器（Application Server）提供了应用程序可以使用的多种服务。在谈到分布式事务时，该服务就称作 XA Resource。当然，在应用程序可以使用 XA Resource 之前，首先要在应用程序服务器中注册和配置 XA Resource。

现在，如果您计划在应用程序中使用 JTA，就必须修改代码，以便还可以与应用程序服务器（Application Server）进行通信。这包括一些附加的方法调用和指定的错误/异常处理。请参阅 清单 3，以了解如何工作。

用 JTA 进行两阶段提交的必要条件
首先，在编写 JTA 应用程序时，您需要合适的 JDK。好消息就是在使用当前的 JDK 时，不需要任何附加包。大多数的 JTA 相关类都在 javax.transaction 和 javax.transaction.xa 中。

您需要用于 DB2 UDB 和 Informix Dynamic Server 的 JDBC 驱动程序。您将需要 Type 4 JDBC 用于 Informix Dynamic Server。DB2 要求您来选择需要哪个 JDBC 驱动程序。有 Type 2、3 和 4 JDBC。在用 JTA 进行编程时，您必须使用 Type 2 或 4 JDBC 驱动程序。为了方便，本文中所演示的所有例子都使用 Type 4 JDBC 驱动程序用于 DB2。（关于各驱动程序之间差别的解释，请查阅手册。）

以上描述说明了应用程序服务器（Application Server）或事务管理器（Transaction Manager）的存在。在下面的例子中，您不会看到“外部”应用程序服务器（Application Server），因为已经使用 DB2XADataSource 和 IfxXADataSource 类直接将之构建到您的应用程序中了。如果您使用一个真正的应用程序服务器（Application Server），那么该应用程序服务器将使用这些类来连接到数据库的本地 XA 调用。

下面的例子（清单 3）演示了一个小型应用程序，该应用程序使用 JTA 实现两阶段提交（Two-Phase-Commit）协议。该例子并不完整，是为了让代码更加易读。

清单 3. 两阶段提交的应用程序

19 import java.io.BufferedReader; 20 import java.io.FileInputStream; 21 import java.io.IOException; 22 import java.io.InputStreamReader; 23 24 import java.sql.Connection; 25 import java.sql.SQLException; 26 import java.sql.Statement; 27 28 import java.util.Properties; 29 30 import javax.sql.XAConnection; 31 import javax.transaction.xa.XAException; 32 import javax.transaction.xa.XAResource; 33 import javax.transaction.xa.Xid; 34 35 import com.ibm.db2.jcc.DB2XADataSource; 36 import com.ibm.db2.jcc.DB2Xid; 37 38 import com.informix.jdbcx.IfxXADataSource; 39 import com.informix.jdbcx.IfxXid;

在第 19-39 行中，您看到了该应用程序中所使用的所有类。大多数类是您所知道的。第 30-33 行中导入的类是使用 JTA 所必要的。同样有意思的是第 35、36 和 38、39 行中的数据库供应商的特定类。xyzXADataSource 类包含了用于启用两阶段提交协议的本地 XA 代码。

44 class DBX { 45 46 private Properties props; 47 private String propertyfile = "jtadb2ifmx.properties"; 48 56 DBX () { 57 58 Connection db2con = null; 59 Connection ifxcon = null; 60 DB2XADataSource db2ds = null; 61 IfxXADataSource ifxds = null; 62 Xid db2xid = null; 63 Xid ifxxid = null; 64 XAConnection db2xacon = null; 65 XAConnection ifxxacon = null; 66 XAResource db2xares = null; 67 XAResource ifxxares = null; 68 69 70 // read the properties 71 props = new Properties (); 72 73 try { 74 props.load (new FileInputStream (propertyfile)); 75 } 76 catch (IOException io) { 77 System.err.println ("Error while accessing the properties file (" + 78 propertyfile + "). Abort."); 79 System.exit (1); 80 }

DBX 类仅仅包含一个私有成员，用于负责属性文件。在该文件中，有一些数据库特定的设置，例如到引擎的端口或登录信息。

该类的构造函数实例化了 SQL 和 XA 相关类：

• Connection： 表示到数据库的传统 SQL（JDBC）连接。
• DB2XADataSource 和 IfxXADataSource： 这些类包含到数据库的本地 XA 调用。使用这些类来启用两阶段提交协议（Two-Phase-Commit-Protocol）。如果有一个应用程序服务器（Application Server），就不需要在程序中处理这些类，因为应用程序服务器（Application Server）封装乐应用程序的这部分。
• Xid： 指一个 XA 事务。本例中，使用了两个不同的数据库，所以需要两个不同的 Xid —— 每个数据库连接（分支）一个。
• XAConnection： JTA 中的一部分。该类允许您启动（提交、准备提交 ...）分布式事务（Distributed Transaction）。
• XAResource： 该资源指的是应用程序服务器（Application Server）所提供的一个服务。同样，本例中，我们不使用应用程序服务器（Application Server）。因此，必须在该应用程序中进行创建和初始化。

83 db2ds = initDB2XADataSource (); 84 ifxds = initIfxXADataSource ();

这些代码行调用一个方法来设置 XADataSource（参见下面）。

360 IfxXADataSource initIfxXADataSource () { 361 362 System.out.print ("Create an IDS XA data source: "); 363 IfxXADataSource ds = new IfxXADataSource (); 364 ds.setDescription ("IDS XA data source"); 365 ds.setServerName (props.getProperty ("ifx.connection.instancename")); 366 ds.setIfxIFXHOST (props.getProperty ("ifx.connection.host")); 367 ds.setPortNumber (Integer.parseInt 368 (props.getProperty ("ifx.connection.port"))); 369 ds.setDatabaseName (props.getProperty ("ifx.connection.databasename")); 370 371 System.out.println ("Okay."); 372 return ds; 373 }

为了方便，这里同时演示了用于 XADataSource 的 IDS 和 DB2 设置，因为它们十分相似。

在安装 IfxDataSource（第 363 行）之后，需要将多个设置指定到数据源对象。这些设置是从属性文件读取的。在设置传统的 JDBC 数据库连接时，所做的这些设置可以与数据库 URL 相比。请注意，没有将任何登录信息指定给数据源对象。登录信息仍然是数据库连接本身中的一部分。

正如上面所提到的，如果存在应用程序服务器（Application Server），还可以由它来进行这一初始化。

在用正确的参数初始化 XADataSource 之后，就将 XADataSource 返回给方法调用者。

85 db2xacon = initDB2XAConnection (db2ds); 86 ifxxacon = initIfxXAConnection (ifxds);

在第 85 和 86 行的代码中，创建了到数据库的 XA Connection。下面描述了如何初始化这些 XA Connection。

329 XAConnection initIfxXAConnection (IfxXADataSource ifxdatasource) { 330 331 XAConnection xacon = null; 332 333 334 try { 335 System.out.print ("Set up IDS XA connection: "); 336 xacon = ifxdatasource.getXAConnection ( 337 props.getProperty ("ifx.connection.username"), 338 props.getProperty ("ifx.connection.password")); 339 340 System.out.println ("Okay."); 341 } 342 catch (SQLException e) { 343 sqlerr (e); 344 } 345 346 return xacon; 347 }

为了设置 XAConnection，要使用前面初始化的 DataSource 对象。第 336 行使用 XADataSource 创建了 XAConnection。为了完成 XAConnection，只需要将身份验证信息传递给该对象。

87 db2xares = initXAResource (db2xacon); 88 ifxxares = initXAResource (ifxxacon);

现在，您准备创建 XAResource 对象了。这些对象将允许您操作两阶段提交（Two-Phase-Commit）。

388 XAResource initXAResource (XAConnection xacon) { 389 390 XAResource xares = null; 391 392 393 try { 394 System.out.print ("Setting up a XA resource: "); 395 xares = xacon.getXAResource (); 396 System.out.println ("Okay."); 397 } 398 catch (SQLException e) { 399 sqlerr (e); 400 } 401 402 return xares; 403 }

XAResource 对象的安装没有什么特别的。该对象是通过调用 XAConnection 中的 getXAResource() 来创建的。

在完成所有关于 XA 的准备之后，就创建到数据库的 JDBC 连接。

89 db2con = getDatabaseConnection (db2xacon); 90 ifxcon = getDatabaseConnection (ifxxacon);

在 getDatabaseConnection() 方法中，建立了一个 JDBC 数据库连接。

250 Connection getDatabaseConnection (XAConnection xacon) { 251 252 Connection con = null; 253 254 try { 255 System.out.print ("Establish database connection: "); 256 con = xacon.getConnection (); 257 System.out.println ("Okay."); 258 } 259 catch (SQLException e) { 260 sqlerr (e); 261 } 262 263 return con; 264 }

这看上去有些混乱。既然已经在第 336 行中设置了 XAConnection，我们为何还需要 JDBC 连接呢？我们为何仍然需要一个“传统”连接的理由是所有其他 JDBC 操作和类（Statement、ResultSet ...）都基于或使用 Connection 对象。如果您看一看 JDBC 类的层次结构图，将会发现 XAConnection 并非是 Connection，反之亦然。XAConnection（实际上，它是 ConnectionPool 的子类）使用 Connection（层次化）。

93 db2xid = createDB2XID (); 94 ifxxid = createIfxXID ();

启动 XA 事务之前的最后一步就是为数据库创建 XA ID 对象。在分布式事务（Distributed Transaction）中进行操作时，总是要使用这个 xid。

183 Xid createIfxXID () { 184 185 Xid xid = null; 186 187 byte [] gid = new byte[1]; 188 byte [] bid = new byte[1]; 189 190 gid[0] = 191 (Byte.decode (props.getProperty ("xid.global"))).byteValue (); 192 bid[0] = 193 (Byte.decode (props.getProperty ("xid.branch.ifx"))).byteValue (); 194 195 System.out.print ("Creating an XID (" + Byte.toString (gid[0]) + ", " + 196 Byte.toString (bid[0]) + ") for Informix: "); 197 198 xid = new IfxXid (0, gid, bid); 199 System.out.println ("Okay."); 200 return xid; 201 }

createIfxXID 方法创建一个 XID（这里：用于 IDS 连接）。正如“两阶段提交协议简介”小节中提到的，XA 事务包含定义该事务的两个元素。上面例子中的重要部分在第 198 行中。IDS XID 是同三个参数创建的。第一个参数是 format ID，它描述在什么格式中构建分布式事务（Distributed Transaction）。您可以省略这一格式信息。第二个参数定义了全局事务 ID（global transaction ID）。该 ID 对于所有参与数据库来说是惟一的。第三个参数表示该全局事务中的事务分支。

在（为 DB2 和 IDS）构建 XID 之后，我们可以使用它们来修改单个事务中的数据。

98 execBranch (db2con, db2xares, db2xid); 99 execBranch (ifxcon, ifxxares, ifxxid);

execBranch() 方法包含了上面为每个连接所定义的 XA 事务中的修改。

215 void execBranch (Connection con, XAResource xares, Xid xid) { 216 217 String sql = props.getProperty ("sql.statement"); 218 219 try { 220 xares.start (xid, javax.transaction.xa.XAResource.TMNOFLAGS); 221 222 Statement stmt = con.createStatement (); 223 stmt.executeUpdate (sql); 224 225 xares.end (xid, javax.transaction.xa.XAResource.TMSUCCESS); 226 } 227 catch (XAException e) { 228 System.err.println ("XA exception caught:"); 229 System.err.println ("Cause : " + e.getCause ()); 230 System.err.println ("Message: " + e.getMessage ()); 231 e.printStackTrace (); 232 } 233 catch (SQLException e) { 234 sqlerr (e); 235 } 236 }

第 219-226 行代码包含了分布式事务（Distributed Transaction）中为相应分支所使用的真正 SQL 语句。分支边界在第 220 行中以 start 方法开始。传递给该方法的参数就是我们已经知道的事务 ID，而第二个参数包含了用于该 XA 事务的一些附加信息。因为这是第一个两阶段提交（Two-Phase-Commit）协议操作，所以不需要向该方法传递任何特殊信息。TMNOFLAGS 说明了这一事实。分支边界终止于第 225 行。标志 TMSUCCESS 描述所有操作都成功。

在 IDS 和 DB2 的分支都执行之后，全局事务就准备提交这些修改。当然，在可以向数据库传送最后的提交之前，必须询问数据库是否准备进行提交。

104 if (prepareCommit (db2xares, db2xid) == XAResource.XA_OK && 105 prepareCommit (ifxxares, ifxxid) == XAResource.XA_OK) { 106 // both branches are ready to commit 107 commitBranch (db2xares, db2xid); 108 commitBranch (ifxxares, ifxxid); 109 } 110 else { 111 // a resource reported an error 112 rollbackBranch (db2xares, db2xid); 113 rollbackBranch (ifxxares, ifxxid); 114 } 116 } // end of constructor

第 104 和 105 行通知数据库准备提交。如果数据库报告 XAResource.XA_OK，就可以提交整个事务。否则，该事务就将被 ROLLBACK 中止。

417 int prepareCommit (XAResource xares, Xid xid) { 418 419 int rc = 0; 420 421 System.out.print ("Prepare XA branch (" + 422 Byte.toString ((xid.getGlobalTransactionId ())[0]) + ", " + 423 Byte.toString ((xid.getBranchQualifier ())[0]) + "): "); 424 425 try { 426 xares.prepare (xid); 427 } 428 catch (XAException e) { 429 xaerr (e); 430 } 431 432 System.out.println ("Okay."); 433 return rc; 434 }

prepareCommit() 方法中最重要的一行在第 426 行中。prepare 方法引起数据库调用两阶段提交协议（Two-Phase-Commit）的“第 1 阶段”。

根据“第 1 阶段”的结果，将提交或中止该分布式事务（Distributed Transaction）。下面是将用于发出这些必要操作的两个方法。

128 void commitBranch (XAResource xares, Xid xid) { 129 130 System.out.print ("Commit XA branch (" + 131 Byte.toString ((xid.getGlobalTransactionId ())[0]) + ", " + 132 Byte.toString ((xid.getBranchQualifier ())[0]) + "): "); 133 134 try { 135 // second parameter is 'false' since we have a two phase commit 136 xares.commit (xid, false); 137 } 138 catch (XAException e) { 139 xaerr (e); 140 } 141 142 System.out.println ("Okay."); 143 }

如果“第 1 阶段”未报告任何错误，就在第 136 行中为 xid 所描述的事务分支提交“第 2 阶段”。方法 commit() 中的第二个参数区分单阶段或两阶段提交操作。因为我们具有一个两阶段提交操作，所以必须将该值设置为 false。

下面的例子展示了如何为数据库回滚事务分支。

446 void rollbackBranch (XAResource xares, Xid xid) { 447 448 System.out.print ("Rollback XA branch (" + 449 Byte.toString ((xid.getGlobalTransactionId ())[0]) + ", " + 450 Byte.toString ((xid.getBranchQualifier ())[0]) + "): "); 451 452 try { 453 xares.rollback (xid); 454 } 455 catch (XAException e) { 456 xaerr (e); 457 } 458 459 System.out.println ("Okay."); 460 }

问题解答
本文中的例子演示了如何在 Java 中使用 JTA 实现两阶段提交（Two-Phase-Commit）协议。在该应用程序中，如果一个事务分支报告了错误，您就要负责进行错误处理。但是“两阶段提交协议简介”小节中提到仍然存在一个问题，那就是如果第 2 阶段中一个事务分支发生故障，该怎么办呢？

如果再次查看程序代码，您可以看到在“第 1 阶段”和“第 2 阶段”之间有一个很小的时间间隔。在这一时间间隔中，出于某种理由，其中某一参与数据库可能崩溃。如果发生了，我们将陷入分布式事务已经部分提交的情形中。

假定下列情形：在“第 1 阶段”之后，您从 DB2 和 IDS 数据库中都收到了“okay”。在下一步中，应用程序成功提交了 DB2 的事务分支。接着，应用程序通知 DB2 事务分支提交事务。现在，在应用程序可以通知 IDS 事务分支提交它这一部分之前，IDS 引擎由于断电发生崩溃。这就是一种部分提交全局事务的情形。您现在该怎么办呢？

在重启之后，DB2 和 IDS 都将尝试恢复打开的事务分支。该引擎等待来自应用程序的提示如何做。如果应用程序没有准备重新发送“第 2 阶段”的提交，该事务分支将被引擎所启动的试探性回滚中止。这是非常糟糕的，因为这将使该全局事务处于不一致状态。

一种解决方案是用一个小型应用程序连接引擎中打开的事务分支，并通知引擎提交或回滚这一打开的事务。如果您使用 IDS 作为后端，那么还有一个隐藏的 onmode 标志，允许您结束打开的事务分支。（onmode -Z xid）。

在 DB2 UDB 中，您可以发出 LIST INDOUBT TRANSACTIONS 来获得打开的 XA 事务的有关信息。您必须查看 DB2 Information Center 中的描述来解决该问题。

上面描述的情形是一个很好的例子，也是使用应用程序服务器（Application Server）或事务监控器（Transaction Monitor）的理由。在使用一个中间层服务器时，就由该服务器负责保持事情正常。

备选方案
清单 1   演示了在应用程序中从数据库读取数据并处理结果的可行方法。如果您的应用程序是“只读”应用程序，IBM® 就提供了另一种解决方案，称作 WebSphere® Information Integrator。WebSphere Information Integrator 使用来自 DB2 UDB（或 DB2 Data Joiner、DB2 Relational Connect）的联邦数据库技术，以将多个数据库（通常：数据源）虚拟化（virtualize）到一个数据库中。不同的、非本地的数据库中的表都链接到 DB2 UDB 中。该操作对于客户机应用程序是完全透明的。客户机可以访问其他数据库中的所有远程表，就像它们是本地 DB2 UDB 表一样。正如 清单 1  中引用的，不再需要连接两个数据库。到 DB2 UDB 的单个连接就已经足够了，因为 DB2 中可以看到 IDS 数据库中的所有表。

目前，WebSphere Information Integrator 不支持两阶段提交，然而，将来的版本将支持两阶段提交协议；这将带来实现企业应用程序的新方法。

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文。
  
• IBM DB2 Information Center
  
• IBM Informix Information Center
  
• Java Transaction API
  
• IBM Informix JDBC Programmers Guide
  
• IBM DB2 Application Developers Guide Pt. II

关于作者 Uwe Weber 是一位 Informix 和 DB2 UDB 方面的 IT 专家。他居住在德国的慕尼黑。Uwe 的 IT 经历始于 1997 年，从那时起，他作为一名 Informix 产品讲师开始在 Informix 工作。IBM 于 2001 年收购 Informix 之后，他调去了技术预售部门，与 EMEA Central 的客户一起工作。

　　1.绝对值

　　S:select abs(-1) value

　　O:select abs(-1) value from dual

　　2.取整(大)

　　S:select ceiling(-1.001) value

　　O:select ceil(-1.001) value from dual

　　3.取整(小)

　　S:select floor(-1.001) value

　　O:select floor(-1.001) value from dual

　　4.取整(截取)

　　S:select cast(-1.002 as int) value

　　O:select trunc(-1.002) value from dual

　　5.四舍五入

　　S:select round(1.23456,4) value 1.23460

　　O:select round(1.23456,4) value from dual 1.2346

　　6.e为底的幂

　　S:select Exp(1) value 2.7182818284590451

　　O:select Exp(1) value from dual 2.71828182

　　7.取e为底的对数

　　S:select log(2.7182818284590451) value 1

　　O:select ln(2.7182818284590451) value from dual; 1

　　8.取10为底对数

　　S:select log10(10) value 1

　　O:select log(10,10) value from dual; 1

　　9.取平方

　　S:select SQUARE(4) value 16

　　O:select power(4,2) value from dual 16

　　10.取平方根

　　S:select SQRT(4) value 2

　　O:select SQRT(4) value from dual 2

　　11.求任意数为底的幂

　　S:select power(3,4) value 81

　　O:select power(3,4) value from dual 81

　　12.取随机数

　　S:select rand() value

　　O:select sys.dbms_random.value(0,1) value from dual;

　　13.取符号

　　S:select sign(-8) value -1

　　O:select sign(-8) value from dual -1

　　14.圆周率

　　S:SELECT PI() value 3.1415926535897931

　　O:不知道

　　15.sin,cos,tan 参数都以弧度为单位

　　例如:select sin(PI()/2) value 得到1(SQLServer)

　　16.Asin,Acos,Atan,Atan2 返回弧度

　　17.弧度角度互换(SQLServer，Oracle不知道)

　　DEGREES:弧度-〉角度

　　RADIANS:角度-〉弧度

　　数值间比较

　　18. 求集合最大值

　　S:select max(value) value from

　　(select 1 value

　　union

　　select -2 value

　　union

　　select 4 value

　　union

　　select 3 value)a

　　O:select greatest(1,-2,4,3) value from dual

　　19. 求集合最小值

　　S:select min(value) value from

　　(select 1 value

　　union

　　select -2 value

　　union

　　select 4 value

　　union

　　select 3 value)a

　　O:select least(1,-2,4,3) value from dual

　　20.如何处理null值(F2中的null以10代替)

　　S:select F1,IsNull(F2,10) value from Tbl

　　O:select F1,nvl(F2,10) value from Tbl

　　21.求字符序号

　　S:select ascii('a') value

　　O:select ascii('a') value from dual

　　22.从序号求字符

　　S:select char(97) value

　　O:select chr(97) value from dual

　　23.连接

　　S:select '11'+'22'+'33' value

　　O:select CONCAT('11','22')||33 value from dual

　　23.子串位置 --返回3

　　S:select CHARINDEX('s','sdsq',2) value

　　O:select INSTR('sdsq','s',2) value from dual

　　23.模糊子串的位置 --返回2,参数去掉中间%则返回7

　　S:select patindex('%d%q%','sdsfasdqe') value

　　O:oracle没发现，但是instr可以通过第四个参数控制出现次数

　　select INSTR('sdsfasdqe','sd',1,2) value from dual 返回6

　　24.求子串

　　S:select substring('abcd',2,2) value

　　O:select substr('abcd',2,2) value from dual

　　25.子串代替 返回aijklmnef

　　S:SELECT STUFF('abcdef', 2, 3, 'ijklmn') value

　　O:SELECT Replace('abcdef', 'bcd', 'ijklmn') value from dual

　　26.子串全部替换

　　S:没发现

　　O:select Translate('fasdbfasegas','fa','我' ) value from dual

　　27.长度

　　S:len,datalength

　　O:length

　　28.大小写转换 lower,upper

　　29.单词首字母大写

　　S:没发现

　　O:select INITCAP('abcd dsaf df') value from dual

　　30.左补空格(LPAD的第一个参数为空格则同space函数)

　　S:select space(10)+'abcd' value

　　O:select LPAD('abcd',14) value from dual

　　31.右补空格(RPAD的第一个参数为空格则同space函数)

　　S:select 'abcd'+space(10) value

　　O:select RPAD('abcd',14) value from dual

　　32.删除空格

　　S:ltrim,rtrim

　　O:ltrim,rtrim,trim

　　33. 重复字符串

　　S:select REPLICATE('abcd',2) value

　　O:没发现

　　34.发音相似性比较(这两个单词返回值一样，发音相同)

　　S:SELECT SOUNDEX ('Smith'), SOUNDEX ('Smythe')

　　O:SELECT SOUNDEX ('Smith'), SOUNDEX ('Smythe') from dual

　　SQLServer中用SELECT DIFFERENCE('Smithers', 'Smythers') 比较soundex的差

　　返回0-4，4为同音，1最高

　　日期函数

　　35.系统时间

　　S:select getdate() value

　　O:select sysdate value from dual

　　36.前后几日

　　直接与整数相加减

　　37.求日期

　　S:select convert(char(10),getdate(),20) value

　　O:select trunc(sysdate) value from dual

　　select to_char(sysdate,'yyyy-mm-dd') value from dual

　　38.求时间

　　S:select convert(char(8),getdate(),108) value

　　O:select to_char(sysdate,'hh24:mm:ss') value from dual

　　39.取日期时间的其他部分

　　S:DATEPART 和 DATENAME 函数 (第一个参数决定)

　　O:to_char函数 第二个参数决定

　　参数---------------------------------下表需要补充

　　year yy, yyyy

　　quarter qq, q (季度)

　　month mm, m (m O无效)

　　dayofyear dy, y (O表星期)

　　day dd, d (d O无效)

　　week wk, ww (wk O无效)

　　weekday dw (O不清楚)

　　Hour hh,hh12,hh24 (hh12,hh24 S无效)

　　minute mi, n (n O无效)

　　second ss, s (s O无效)

　　millisecond ms (O无效)

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

　　40.当月最后一天

　　S:不知道

　　O:select LAST_DAY(sysdate) value from dual

　　41.本星期的某一天(比如星期日)

　　S:不知道

　　O:SELECT Next_day(sysdate,7) vaule FROM DUAL;

　　42.字符串转时间

　　S:可以直接转或者select cast('2004-09-08'as datetime) value

　　O:SELECT To_date('2004-01-05 22:09:38','yyyy-mm-dd hh24-mi-ss') vaule FROM DUAL;

　　43.求两日期某一部分的差(比如秒)

　　S:select datediff(ss,getdate(),getdate()+12.3) value

　　O:直接用两个日期相减(比如d1-d2=12.3)

　　SELECT (d1-d2)*24*60*60 vaule FROM DUAL;

　　44.根据差值求新的日期(比如分钟)

　　S:select dateadd(mi,8,getdate()) value

　　O:SELECT sysdate+8/60/24 vaule FROM DUAL;

　　45.求不同时区时间

　　S:不知道

　　O:SELECT New_time(sysdate,'ydt','gmt' ) vaule FROM DUAL;

　　-----时区参数,北京在东8区应该是Ydt-------

　　AST ADT 大西洋标准时间

　　BST BDT 白令海标准时间

　　CST CDT 中部标准时间

　　EST EDT 东部标准时间

　　GMT 格林尼治标准时间

　　HST HDT 阿拉斯加?夏威夷标准时间

　　MST MDT 山区标准时间

　　NST 纽芬兰标准时间

　　PST PDT 太平洋标准时间

　　YST YDT YUKON标准时间

　　或许很久以前，大家都觉得Oracle数据库的安全并不存在隐患，因为Oracle公司在去年11月份开始促销其数据库软件时提出的口号是“只有Oracle9i能够做到绝对安全”。但是不管它这么说是为了促销，还是为了扩大知名度，总之伴去年12 月份，英国的安全专家 David Litchfield 发现的9iAS 中存在的程序错误导致的缓冲溢出漏洞以及后来，PenTest Limited 和 eEye Digital Security 各自提出了一个小的漏洞，所有使用Oracle公司产品的人都不由地紧张了原本松弛的大脑--这个对于用户来说，毕竟关系到了自己的“身家性命”。

　　下面笔者将带着大家走进Oracle数据安全的世界。由于笔者水平有限，所以不足之处在所难免，望大家不吝赐教。

　　(一)Oracle数据库的一些基本常识

　　这里仅仅是为了以后的安全奠定一些基础，因为我们后面要用到它们。

　　1.Oracle所包含的组件:

　　在 Oracle，数据库是指整个 Oracle RDBMS 环境，它包括以下组件:

　　·Oracle 数据库进程和缓冲(实例)。

　　·SYSTEM 表空间包含一个集中系统类目，它可以由一个或多个数据文件构成。

　　·其它由数据库管理员 (DBA)(可选)定义的表空间，每个都由一个或多个数据文件构成。

　　·两个以上的联机恢复日志。

　　·归档恢复日志(可选)。

　　·其它文件(控制文件、Init.ora、Config.ora 等)。

　　每个 Oracle 数据库都在一个中央系统类目和数据字典上运行，它位于SYSTEM 表空间。

　　2.关于“日志”

　　Oracle数据库使用几种结构来保护数据:数据库后备、日志、回滚段和控制文件。下面我们将大体上了解一下作为主要结构之一的“日志”:

　　每一个Oracle数据库实例都提供日志，记录数据库中所作的全部修改。每一个运行的Oracle数据库实例相应地有一个在线日志，它与Oracle后台进程LGWR一起工作，立即记录该实例所作的全部修改。归档(离线)日志是可选择的，一个Oracle数据库实例一旦在线日志填满后，可形成在线日志归档文件。归档的在线日志文件被唯一标识并合并成归档日志。

　　·关于在线日志:一个Oracle数据库的每一实例有一个相关联的在线日志。一个在线日志由多个在线日志文件组成。在线日志文件(online redo log file)填入日志项(redo entry)，日志项记录的数据用于重构对数据库所作的全部修改。

　　·关于归档日志:Oracle要将填满的在线日志文件组归档时，则要建立归档日志(archived redo log)。其对数据库备份和恢复有下列用处:

　　<1>数据库后备以及在线和归档日志文件，在操作系统和磁盘故障中可保证全部提交的事物可被恢复。

　　<2>在数据库打开和正常系统使用下，如果归档日志是永久保存，在线后备可以进行和使用。

　　数据库可运行在两种不同方式下:NOARCHIVELOG方式或ARCHIVELOG 方式。数据库在NOARCHIVELOG方式下使用时，不能进行在线日志的归档。如果数据库在ARCHIVELOG方式下运行，可实施在线日志的归档。

　　3.物理和逻辑存储结构:

　　Oracle RDBMS是由表空间组成的，而表空间又是由数据文件组成的。表空间数据文件被格式化为内部的块单位。块的大小，是由DBA在Oracle第一次创建的时候设置的，可以在512到8192个字节的范围内变动。当一个对象在Oracle表空间中创建的时候，用户用叫做长度的单位(初始长度((initial extent)、下一个长度(next extent)、最小长度(min extents)、以及最大长度(max extents))来标明该对象的空间大小。一个Oracle长度的大小可以变化，但是要包含一个由至少五个连续的块构成的链。

　　4.Oracle与Microsoft SQL Server比较下的联网协议:

　　(二)Oracle数据安全的维护

　　记得某位哲学家说过:“事物的变化离不开内因和外因。”那么对于Oracle数据安全这个话题而言，也势必分为“内”和“外”两个部分。那么好，我们就先从“内”开始说起:

　　§1.从Oracle系统本身说起

　　我们先抛开令人闻风色变的“hacker”和其他一些外部的原因，先想一下我们的数据库。什么硬盘损坏，什么软件受损，什么操作事物……一系列由于我们的“疏忽”而造成的系统问题就完全可以让我们辛苦建立的数据库中的数据一去不复返。那么，我们就先从自己身上找找原因吧。

　　【一】解决系统本身问题的方法--数据库的备份及恢复

　　·数据库的备份:

　　关于Oracle数据库的备份，标准地有三中办法:导出/导入(Export/Import)、冷备份、热备份。导出备份是一种逻辑备份，冷备份和热备份是物理备份。

　　<1>导出/导入(Export/Import)

　　利用Export可将数据从数据库中提取出来，利用Import则可将提取出来的数据送回Oracle数据库中去。

　　a.简单导出数据(Export)和导入数据(Import)

　　Oracle支持三种类型的输出:

　　(1)表方式(T方式)，将指定表的数据导出。

　　(2)用户方式(U方式)，将指定用户的所有对象及数据导出。

　　(3)全库方式(Full方式)，将数据库中的所有对象导出。

　　数据导出(Import)的过程是数据导入(Export)的逆过程，它们的数据流向不同。

　　b.增量导出/导入

　　增量导出是一种常用的数据备份方法，它只能对整个数据库来实施，并且必须作为SYSTEM来导出。在进行此种导出时，系统不要求回答任何问题。导出文件名缺省为export.dmp，如果不希望自己的输出文件定名为export.dmp，必须在命令行中指出要用的文件名。

　　增量导出包括三个类型:

　　(1)“完全”增量导出(Complete)

　　即备份整个数据库，比如:

　　$exp system/manager inctype=complete file=990702.dmp

　　(2)“增量型”增量导出

　　备份上一次备份后改变的数据。比如:

　　$exp system/manager inctype=incremental file=990702.dmp

　　(3)“累计型”增量导出(Cumulative)

　　累计型导出方式只是导出自上次“完全” 导出之后数据库中变化了的信息。比如:

　　$exp system/manager inctype=cumulative file=990702.dmp

　　数据库管理员可以排定一个备份日程表，用数据导出的三个不同方式合理高效地完成。比如数据库的备份任务可作如下安排:

　　·星期一:完全导出(A)

　　·星期二:增量导出(B)

　　·星期三:增量导出(C)

　　·星期四:增量导出(D)

　　·星期五:累计导出(E)

　　·星期六:增量导出(F)

　　·星期日:增量导出(G)

　　如果在星期日，数据库遭到意外破坏，数据库管理员可按以下步骤来恢复数据库:

　　第一步:用命令CREATE DATABASE重新生成数据库结构;

　　第二步:创建一个足够大的附加回段。

　　第三步:完全增量导入A:

　　$imp system./manager inctype= RECTORE FULL=Y FILE=A

　　第四步:累计增量导入E:

　　$imp system/manager inctype= RECTORE FULL=Y FILE =E

　　第五步:最近增量导入F:

　　$imp system/manager inctype=RESTORE FULL=Y FILE=F

　　<2>冷备份

　　冷备份发生在数据库已经正常关闭的情况下，当正常关闭时会提供给我们一个完整的数据库。冷备份是将关键性文件拷贝到另外位置的一种说法。对于备份Oracle信息而言，冷备份是最快和最安全的方法。冷备份的优点是:

　　·是非常快速的备份方法(只需拷贝文件)

　　·容易归档(简单拷贝即可)

　　·容易恢复到某个时间点上(只需将文件再拷贝回去)

　　·能与归档方法相结合，作数据库“最新状态”的恢复。

　　·低度维护，高度安全。

　　但冷备份也有如下不足:

　　·单独使用时，只能提供到“某一时间点上”的恢复。

　　·在实施备份的全过程中，数据库必须要作备份而不能作其它工作。也就是说，在冷备份过程中，数据库必须是关闭状态。

　　·若磁盘空间有限，只能拷贝到磁带等其它外部存储设备上，速度会很慢。

　　·不能按表或按用户恢复。

　　如果可能的话(主要看效率)，应将信息备份到磁盘上，然后启动数据库(使用户可以工作)并将所备份的信息拷贝到磁带上(拷贝的同时，数据库也可以工作)。冷备份中必须拷贝的文件包括:

　　·所有数据文件

　　·所有控制文件

　　·所有联机REDO LOG文件

　　·Init.ora文件(可选)

　　值得注意的是冷备份必须在数据库关闭的情况下进行，当数据库处于打开状态时，执行数据库文件系统备份是无效的

　　下面是做冷备份的完整例子:

　　(1) 关闭数据库$sqldba lmode=y

　　SQLDBA >connect internal;

　　SQLDBA >shutdown normal;

　　(2) 用拷贝命令备份全部的时间文件、重做日志文件、控制文件、初始化参数文件

　　SQLDBA >! cp < file > < backup directory >

　　(3) 重启Oracle数据库

　　$sqldba lmode=y

　　SQLDBA >connect internal;

　　SQLDBA >startup;

　　<3>热备份

　　热备份是在数据库运行的情况下，采用archivelog mode方式备份数据的方法。所以，如果你有昨天夜里的一个冷备份而且又有今天的热备份文件，在发生问题时，就可以利用这些资料恢复更多的信息。热备份要求数据库在Archivelog方式下操作，并需要大量的档案空间。一旦数据库运行在archivelog状态下，就可以做备份了。热备份的命令文件由三部分组成:

　　1.数据文件一个表空间一个表空间地备份。

　　(1)设置表空间为备份状态

　　(2)备份表空间的数据文件

　　(3)恢复表空间为正常状态

　　2.备份归档log文件。

　　(1)临时停止归档进程

　　(2)log下那些在archive redo log目标目录中的文件

　　(3)重新启动archive进程

　　(4)备份归档的redo log 文件

　　3.用alter database backup controlfile命令来备份拷贝文件

　　热备份的优点是:

　　·可在表空间或数据文件级备份，备份时间短。

　　·备份时数据库仍可使用。

　　·可达到秒级恢复(恢复到某一时间点上)。

　　·可对几乎所有数据库实体作恢复。

　　·恢复是快速的，在大多数情况下在数据库仍工作时恢复。

　　热备份的不足是:

　　·不能出错，否则后果严重。

　　·若热备份不成功，所得结果不可用于时间点的恢复。

　　·因难于维护，所以要特别仔细小心，不允许“以失败而告终”。

　　【二】来自内部的另外一个隐患--用户管理以及密码问题

　　在这里，其实作为一个差不多点的数据库管理员都很清楚，Oracle数据库本身就使用了很多种手段来加强数据库的安全性，经常见到的就有密码，角色，权限等等。那么我们就从最简单的DBSNMP

　　说起:

　　Oralce数据库如果采用典型安装后，自动创建了一个叫做DBSNMP的用户，该用户负责运行Oracle系统的智能代理(Intelligent Agent)，该用户的缺省密码也是“DBSNMP”。如果忘记修改该用户的口令，任何人都可以通过该用户存取数据库系统。现在我们来看一下该用户具有哪些权限和角色，然后来分析一下该用户对数据库系统可能造成的损失。

　　启动SQL/PLUS程序，使用该用户登录进入:

　　SQL> select * from session_privs;

　　CREATE SESSION

　　ALTER SESSION

　　UNLIMITED TABLESPACE

　　CREATE TABLE

　　CREATE CLUSTER

　　CREATE SYNONYM

　　CREATE PUBLIC SYNONYM

　　CREATE VIEW

　　CREATE SEQUENCE

　　CREATE DATABASE LINK

　　CREATE PROCEDURE

　　CREATE TRIGGER

　　ANALYZE ANY

　　CREATE TYPE

　　CREATE OPERATOR

　　CREATE INDEXTYPE

　　可以看到该用户不是SYS或SYSTEM管理用户，然而，它却具有两个系统级权限:UNLIMITED TABLESPACE和CREATE PUBLIC SYNONYM。

　　看到这两个权限你应该马上想到，这些都是安全隐患，尤其是UNLIMITED TABLESPACE，它是破坏数据库系统的攻击点之一。如果这时候你还依然认为，即使有人利用这个没有修改的口令登录进数据库也造成不了什么损失的话，我就不得不提醒你:该用户具有UNLIMITED TABLESPACE的系统权限，它可以写一个小的脚本，然后恶意将系统用垃圾数据填满，这样数据库系统也就无法运行，并将直接导致最终的瘫痪。目前很多数据库系统都要求7X24的工作，如果出现了系统用垃圾数据填满的情况，那么，等数据库系统恢复时，恐怕不可挽回的损失已经造成了。

　　可是除了 DBSNMP 还有很多其他的用户，怎么办呢?让我们先看一下目前普遍存在于Oracle数据库中的用户管理问题:

　　(1)权限过大:对ORACLE数据库编程和浏览的一般用户常常具有DBA (数据库管理员权限)，

　　能对数据库系统做任何修改或删除。

　　(2)安全性差:很多ORACLE用户缺省存储位置都在系统表空间，这样不仅影响系统的正常工

　　作，而且不同用户的数据信息互相影响、透明，保密性差。随着数据的不断加入，

　　有可能使整个数据库系统崩溃。

　　(3)密码有规律:在ORACLE调试初期形成的用户名和密码一致的不良习惯保留到现在;系统用户SYS和SYSTEM的密码也众所皆知。

　　知道了这些普遍的“毛病”，我们怎么做呢?下面是我的一些建议:

　　(1)ORACLE DBA (数据库管理员)的规范

　　·SUN Solaris操作系统下ORACLE用户密码应严格保密，绝不该把密码设成

　　ORACLE;并指定专门的数据库管理员定期修改。

　　·ORACLE初始化建立的SYS和SYSTEM系统管理员用户密码应由原来MANAGER改成别的不易被记忆的字符串。

　　·ORACLE WEB SERVER的管理端口具备DBA浏览数据库的能力，因此其管理者

　　ADMIN的密码也应保密，不该把密码设成MANAGER;并指定专门的数据库管理员定

　　期修改。

　　·ORACLE DBA最好在SUN SPARC服务器控制台上用窗口式界面实现管理。前提

　　是ORACLE用户启动服务器，然后在窗口式命令行下输入SVRMGRM，即启动了ORACLE SERVER MANAGER菜单式管理;用SYSDBA身份登录后，就可做数据库系统维护工作了

　　(2)SQL*PLUS编程用户的规范

　　·存储结构的规范

　　考虑到用SQL*PLUS编程可实现各行各业、各公司、各部门多种多样的应用需求，我们的SQL*PLUS编程用户也应该朝这个方向规范:不同种类的应用必须有不同的用户;不同种类的应用必须有不同的存储位置，包括物理文件、缺省表空间、临时表空间的创建和规划:当准备编写某一较大规模(从ORACLE数据量和面向用户量考虑)应用程序时，首先应该创建一个逻辑的存储位置-表空间，同时定义物理文件的存放路径和所占硬盘的大小。

　　①、物理文件缺省的存放路径在/oracle_home/dbs下，在命令行下用UNIX指令df -k 可查看硬盘资源分区的使用情况。如果oracle_home使用率达90‰以上，而且有一个或多个较为空闲的硬盘资源分区可以利用，我们最好把物理文件缺省的存放路径改到较为空闲的硬盘资源分区路径下。在此路径下我们可以这样规划资源物理文件的存储:

　　xxx表空间

　　xxx行业/ xxx公司/ xxx 部门/ xxx 服务.dbf

　　DEMO表空间

　　default_datafile_home1/col /elec/sys4/demo1.dbf

　　default_datafile_home1/col /elec/sys4/demo2.dbf

　　公司系统四部摹拟演示系统物理文件

　　HUMAN表空间

　　default_datafile_home1/col/elec/human/human.dbf

　　公司人事部人事管理系统物理文件

　　BOOK表空间

　　default_datafile_home1/col/elec/book/book.dbf

　　公司资料室图书管理系统物理文件

　　QUESTION表空间

　　default_datafile_home1/col/elec/client/question.dbf

　　公司客户服务部问题库系统物理文件

　　PC表空间

　　default_datafile_home1/col/chaoxun/client/pc.dbf

　　公司PC机售后服务系统物理文件

　　……表空间

　　default_datafile_home2/……………………………

　　等等

　　说明:其中default_datafile_home1指oracle_home/dbs;

　　default_datafile_home2指较为空闲的硬盘资源分区路径。

　　②、物理文件的大小根据应用系统的数据量、数据对象、程序包的多少来定。一般用于摹拟演示的小系统，表空间初始的物理文件为2M即能满足要求，如果信息量满，还可以增加物理文件，扩充表空间(每次扩充大小也可暂定为2M);一般实际运行的应用系统可适当增加表空间初始的物理文件大小，但也不要一次分配太大(因为不易回收空间，却易扩充空间)，这也需要根据具体情况具体分析:信息量大、需长时间保存的应用在条件允许情况下，表空间可以大到几百M甚至上G;信息量小、短期经常刷新的应用，表空间可以控制在2M以下。

　　③、表空间的名称应该采用同系统应用相似的英文字符或字符缩写，表空间所对应的一个或多个物理文件名也应有相关性。不同用户所处的缺省表空间不同，存储的信息就不能互相访问。这比把所有用户信息都储存在系统表空间，安全性大大提高了。如果用ORACLE WEB SERVER管理端口创建的用户，其缺省和临时表空间一定是系统表空间，DBA切记要改变用户的缺省表空间。临时表空间存放临时数据段，处理一些排序、合并等中间操作，根据实际应用的需求可以把它们放在专门创建的表空间里;如果系统表空间大，也可以把它们放在系统表空间。用户创建的数据索引最好和数据文件分开存放在不同表空间，以减少数据争用和提高响应速度。

　　·密码和用户名的规范

　　有相当数量的ORACLE用户名和密码一致，这是个很不安全的因素。我们建议ORACLE用户名和密码一定不要一样，密码最好在五，六位字符以上。不同用户间不应该使用相同的密码。用户名的定义可根据实际应用的英文名来设，而依据编程人员的姓名定义的用户名实际上不规范，可在日后的工作中结合上述有关存储结构规范的说明逐步改进。

　　(3)特殊要求用户的规范

　　在ORACLE数据库使用过程中，还会遇到一些有特殊要求的用户:非编程人员需要对某个表有查询、增加、删除、修改的权利。DBA应创建一个这样的用户，先确定用户名和密码，再规定相关应用所在缺省表空间(包含某个表)和临时表空间，最后TABLE属主给其授权:赋予CONNECT角色SELECT、INSERT、DELETE、UPDATE ON THE TABLE的对象级权限，这可根据实际需求自由取舍。

　　举例:●给新用户授于对象级权限(命令行方式):

　　假设新用户NEW2需要有查询、删除、修改DCD用户的表EMP。

　　%svrmgrl

　　SVRMGR>connect internal; 以系统管理员登录

　　SVRMGR>create user new2 identified by new2345 default tablespace app;

　　SVRMGR>connect dcd/dcdpwd; 以dcd用户登录

　　SVRMGR>grant connect to new2;

　　SVRMGR>grant select on emp to new2;

　　SVRMGR>grant delete on emp to new2;

　　SVRMGR>grant update on emp to new2;

　　说了这么多关于用户的问题，那么接下来我们就详细得说一下关于密码文件的使用以及维护--在Oracle数据库系统中，用户如果要以特权用户身份(INTERNAL/SYSDBA/SYSOPER)登录Oracle数据库可以有两种身份验证的方法:即使用与操作系统集成的身份验证或使用Oracle数据库的密码文件进行身份验证。因此，管理好密码文件，对于控制授权用户从远端或本机登录Oracle数据库系统，执行数据库管理工作，具有重要的意义。

　　Oracle数据库的密码文件存放有超级用户INTERNAL/SYS的口令及其他特权用户的用户名/口令，它一般存放在ORACLE_HOME\DATABASE目录下。

　　·密码文件的创建:

　　在使用Oracle Instance Manager创建一数据库实例的时侯，在ORACLE_HOME\DATABASE目录下还自动创建了一个与之对应的密码文件，文件名为PWDSID.ORA，其中SID代表相应的Oracle数据库系统标识符。此密码文件是进行初始数据库管理工作的基础。在此之后，管理员也可以根据需要，使用工具ORAPWD.EXE手工创建密码文件，命令格式如下:

　　C:\ >ORAPWD　FILE=< FILENAME >　PASSWORD =< PASSWORD > ENTRIES=< MAX_USERS >

　　各命令参数的含义为:

　　FILENAME:密码文件名;

　　PASSWORD:设置INTERNAL/SYS帐号的口令;

　　MAX_USERS:密码文件中可以存放的最大用户数，对应于允许以SYSDBA/SYSOPER权限登录数据库的最大用户数。由于在以后的维护中，若用户数超出了此限制，则需要重建密码文件，所以此参数可以根据需要设置得大一些。

　　有了密码文件之后，需要设置初始化参数REMOTE_LOGIN_PASSWORDFILE来控制密码文件的使用状态。

　　·设置初始化参数REMOTE_LOGIN_PASSWORDFILE:

　　在Oracle数据库实例的初始化参数文件中，此参数控制着密码文件的使用及其状态。它可以有以下几个选项:

　　NONE:指示Oracle系统不使用密码文件，特权用户的登录通过操作系统进行身份验证;

　　EXCLUSIVE:指示只有一个数据库实例可以使用此密码文件。只有在此设置下的密码文件可以包含有除INTERNAL/SYS以外的用户信息，即允许将系统权限SYSOPER/SYSDBA授予除INTERNAL/SYS以外的其他用户。

　　SHARED:指示可有多个数据库实例可以使用此密码文件。在此设置下只有INTERNAL/SYS帐号能被密码文件识别，即使文件中存有其他用户的信息，也不允许他们以SYSOPER/SYSDBA的权限登录。此设置为缺省值。

　　在REMOTE_LOGIN_PASSWORDFILE参数设置为EXCLUSIVE、SHARED情况下，Oracle系统搜索密码文件的次序为:在系统注册库中查找ORA_SID_PWFILE参数值(它为密码文件的全路径名);若未找到，则查找ORA_PWFILE参数值;若仍未找到，则使用缺省值ORACLE_HOME\DATABASE\PWDSID.ORA;其中的SID代表相应的Oracle数据库系统标识符。

　　·向密码文件中增加、删除用户:

　　当初始化参数REMOTE_LOGIN_PASSWORDFILE设置为EXCLUSIVE时，系统允许除INTERNAL/SYS以外的其他用户以管理员身份从远端或本机登录到Oracle数据库系统，执行数据库管理工作;这些用户名必须存在于密码文件中，系统才能识别他们。由于不管是在创建数据库实例时自动创建的密码文件，还是使用工具ORAPWD.EXE手工创建的密码文件，都只包含INTERNAL/SYS用户的信息;为此，在实际操作中，可能需要向密码文件添加或删除其他用户帐号。

　　由于仅被授予SYSOPER/SYSDBA系统权限的用户才存在于密码文件中，所以当向某一用户授予或收回SYSOPER/SYSDBA系统权限时，他们的帐号也将相应地被加入到密码文件或从密码文件中删除。由此，向密码文件中增加或删除某一用户，实际上也就是对某一用户授予或收回SYSOPER/SYSDBA系统权限。

　　要进行此项授权操作，需使用SYSDBA权限(或INTERNAL帐号)连入数据库，且初始化参数REMOTE_LOGIN_PASSWORDFILE的设置必须为EXCLUSIVE。具体操作步骤如下:

　　创建相应的密码文件;

　　设置初始化参数REMOTE_LOGIN_PASSWORDFILE=EXCLUSIVE;

　　使用SYSDBA权限登录: CONNECT　SYS/internal_user_passsword　AS　SYSDBA;

　　启动数据库实例并打开数据库;

　　创建相应用户帐号，对其授权(包括SYSOPER和SYSDBA): 授予权限:GRANT　SYSDBA　TO　user_name;

　　收回权限:REVOKE　SYSDBA　FROM　user_name;

　　现在这些用户可以以管理员身份登录数据库系统了;

　　·使用密码文件登录:

　　有了密码文件后，用户就可以使用密码文件以SYSOPER/SYSDBA权限登录Oracle数据库实例了，注意初始化参数REMOTE_LOGIN_PASSWORDFILE应设置为EXCLUSIVE或SHARED。任何用户以SYSOPER/SYSDBA的权限登录后，将位于SYS用户的Schema之下，以下为两个登录的例子:

　　1. 以管理员身份登录:

　　假设用户scott已被授予SYSDBA权限，则他可以使用以下命令登录:

　　CONNECT　scott/tiger　AS　SYSDBA

　　2. 以INTERNAL身份登录:

　　CONNECT　INTERNAL/INTERNAL_PASSWORD

　　·密码文件的维护:

　　1. 查看密码文件中的成员:

　　可以通过查询视图V$PWFILE_USERS来获取拥有SYSOPER/SYSDBA系统权限的用户的信息，表中SYSOPER/SYSDBA列的取值TRUE/FALSE表示此用户是否拥有相应的权限。这些用户也就是相应地存在于密码文件中的成员。

　　2. 扩展密码文件的用户数量:

　　当向密码文件添加的帐号数目超过创建密码文件时所定的限制(即ORAPWD.EXE工具的MAX_USERS参数)时，为扩展密码文件的用户数限制，需重建密码文件，具体步骤如下:

　　a) 查询视图V$PWFILE_USERS，记录下拥有SYSOPER/SYSDBA系统权限的用户信息;

　　关闭数据库;

　　c) 删除密码文件;

　　d) 用ORAPWD.EXE新建一密码文件;

　　e) 将步骤a中获取的用户添加到密码文件中。

　　3. 修改密码文件的状态:

　　密码文件的状态信息存放于此文件中，当它被创建时，它的缺省状态为SHARED。可以通过改变初始化参数REMOTE_LOGIN_PASSWORDFILE的设置改变密码文件的状态。当启动数据库事例时，Oracle系统从初始化参数文件中读取REMOTE_LOGIN_PASSWORDFILE参数的设置;当加载数据库时，系统将此参数与口令文件的状态进行比较，如果不同，则更新密码文件的状态。若计划允许从多台客户机上启动数据库实例，由于各客户机上必须有初始化参数文件，所以应确保各客户机上的初始化参数文件的一致性，以避免意外地改变了密码文件的状态，造成数据库登陆的失败。

　　4. 修改密码文件的存储位置:

　　密码文件的存放位置可以根据需要进行移动，但作此修改后，应相应修改系统注册库有关指向密码文件存放位置的参数或环境变量的设置。

　　5. 删除密码文件:

　　在删除密码文件前,应确保当前运行的各数据库实例的初始化参数REMOTE_LOGIN_PASSWORDFILE皆设置为NONE。在删除密码文件后，若想要以管理员身份连入数据库的话，则必须使用操作系统验证的方法进行登录。

　　但是管理员都觉得乏味，因为在管理员中流行一种很简单的加密办法--就是经常，很频繁地修改自己的密码。可是，每次修改都跟打一次仗似的--因为更新程序并不是每个人都愿意做的事情。

　　那么有没有什么简单点的办法呢?请往下看:

　　模型:Oracle7.3;开发工具:Develope2000。收费系统(在数据库中的名称是SFYY)，其Client端分散在市区的数个营业点，通过城域网与主机(小型 机)相连。

　　过程:

　　·在收费小型机Oracle系统的system用户(DBA)下，创建新用户test;

　　create user test

　　identified by carton

　　default tablespace dataspace1

　　quota 100K

　　·对test用户授以权限;

　　grant create session to test;

　　grant resource to test;

　　·在test用户下建立一个存储函数mmtranslate,它其实是一个加密程序。下面是一个简 单的例子。

　　function mmtranslate(m varchar2)

　　return varchar2

　　as

　　i number(2);

　　kk varchar2(10);

　　begin

　　kk:=′′;

　　i:=1;

　　loop

　　if i<=length(m) then

　　if instr(′1234567890′,substr(m,i,1),1,1)>0 then

　　kk:=kk||chr(100+to_number(substr(m,i,1)));

　　elseif instr(‘wxyz‘,substr(m,i,1),1,1)>0 then

　　kk:=kk||chr(-8+ascii(substr(m,i,1)));

　　else

　　kk:=kk||chr(4+ascii(substr(m,i,1)));

　　end if;

　　else

　　exit;

　　end if;

　　i:=i+1;

　　end loop;

　　return kk;

　　exception

　　when others then

　　return ′-1′;

　　end;

　　·在test用户下建表mmtest并插入记录:

　　create table mmtest

　　(usnamevarchar2(6),------用户名称

　　mimavarchar2(6)------加密前的密码);

　　insert into mmtest values( ‘sfyy‘,‘eds2‘);

　　commit;

　　·执行以下语句

　　SQL>select mmtranslate(‘eds2‘) from dual;

　　MMTRANSLATE(‘EDS2‘)

　　----------------------------------------

　　ihwf

　　利用DBA权限更改sfyy的密码为上面语句的执行结果:

　　alter user sffy

　　identified by ihwf; ;

　　·修改应用程序，对于开发环境是Develope2000的程序来说，主要是修改主程序的on-lo gon触发器:

　　declare

　　mm varchar2(6);

　　begin

　　logon(‘test‘,‘carton‘);

　　select mima into mm from mmtest where usname=‘sfyy‘;

　　mm:=mmtranslate(mm);

　　logout;

　　logon(‘sfyy‘,mm);

　　end;

　　然后再利用触发器WHEN-NEW-FROM-INSTANCE执行Callfrom或Newform等 命令，进入业务处理程序。这个主程序应当仅仅由管理员来掌握,编译之后将执行文件下发 到各收费点的Clien端。

　　·在System用户下，利用Oracle提供的pupbld.sql,建立表Productuserprofile,执行下面这样的命令，限制在非开发状态Sql命令的使用,例如

　　insert into productuserprofile

　　(product,userid,attribute,charvalue) values

　　(‘SQL*Plus‘,‘TEST‘,‘CONNECT‘,‘DISABLED‘);

　　insert into productuserprofile

　　(product,userid,attribute,charvalue) values

　　(‘SQL*Plus‘,‘SFYY‘,‘DELETE‘,‘DISABLED‘);这样，在SQL状态下，根本无法连接到TEST用户，而在 sfyy用户下，delete命令将不能执行。当然，DBA可以改变这些设置。

　　当然了，这个仅仅是属于一种“应用技巧”，但是足可以把那些每天忙于更新系统的管理员舒服好几天了。但是另一方面，还要加强对源程序的管理，在Client端只存放执行程序。加强审计，发现异常现象，及时处理。这样才可以做到更高一层的“安全”。

　　在下面，我主要是向大家介绍一个REM对GHXXB制立数据库触发子,密码的加密程序。

　　REM 对GHXXB制立数据库触发子(当INSERT OR UPDATE GHXXB时触发)

　　drop trigger scjmmm;

　　create or replace trigger scjmmm

　　before insert or update of mm On ghxxb For each Row

　　Begin

　　:new.mm:=ENCRYPT(:new.mm,:NEW.GH,TO_CHAR(SYSDATE,‘SS‘));

　　End;

　　/

　　---------------------------密码的加密程序ENCRYPT----------------------

　　Create or Replace

　　Function ENCRYPT (Inpass In Varchar2,IN_GH In Varchar2,IN_SS In Varchar2)

　　Return Varchar2 Is

　　bcs varchar2(20);

　　bcs1 number;

　　cs number;

　　jg number;

　　m_gh VARCHAR2(4);

　　m_mm VARCHAR2(20);

　　Begin

　　m_gh:=IN_GH;

　　m_mm:=INPASS;

　　cs:=TO_NUMBER(IN_SS);

　　If cs<=1 then cs:=77 ;end if;

　　bcs:=substr(to_char(ascii(substr(m_gh,1,1))),1,2);

　　If bcs<‘1‘ then bcs:=‘7‘ ;end if;

　　m_gh:=substr(m_gh,2);

　　Loop EXIT WHEN nvl(length(m_gh),0)=0 ;

　　bcs:=bcs||substr(to_char(ascii(substr(m_gh,1,1))),-1,1);

　　m_gh:=substr(m_gh,2);

　　End loop;

　　Loop EXIT WHEN nvl(length(m_mm),0)=0 ;

　　bcs:=bcs||substr(to_char(ascii(substr(m_mm,1,1))),-1,1);

　　m_mm:=substr(m_mm,2);

　　End loop;

　　bcs1:=to_number(bcs);

　　jg:=cs*bcs1;

　　Loop EXIT WHEN length(to_char(jg))>13;

　　jg:=jg*cs ;

　　End loop;

　　RETURN(IN_SS||substr(to_char(jg),1,14));

　　End;

　　/

　　总结上面的东西，我们仅仅是从自身做起，知道了怎么维护Oracle数据库安全这个话题的“皮毛”。可是，对于这个似乎永远也说不完的话题，我们光知道怎么从内部“防御”就够了吗?不要忘了，在外面，还有一群虎视耽耽的“hacker”在盯着你的数据库--因为这里面有他们想要的东西。

　　所以，请大家关注好下一个话题:

　　§2.不被“hacker”入侵的几个建议

　　我们的目标是:没有蛀牙!(开个玩笑~!呵呵)其实应该是:它应尽可能地堵住潜在的各种漏洞，防止非法用户利用它们侵入数据库系统。对于数据库数据的安全问题，数据库管理员可以参考有关系统双机热备份功能以及数据库的备份和恢复的资料。

　　以下就数据库系统不被非法用户侵入这个问题作进一步的阐述。

　　·组和安全性:在操作系统下建立用户组也是保证数据库安全性的一种有效方法。Oracle程序为了安全性目的一般分为两类:一类所有的用户都可执行，另一类只DBA可执行。在Unix环境下组设置的配置文件是/etc/group，关于这个文件如何配置，请参阅Unix的有关手册，以下是保证安全性的几种方法:

　　(1)在安装Oracle Server前，创建数据库管理员组(DBA)而且分配root和Oracle软件拥有者的用户ID给这个组。DBA能执行的程序只有710权限。在安装过程中SQL*DBA系统权限命令被自动分配给DBA组。

　　(2)允许一部分Unix用户有限制地访问Oracle服务器系统，增加一个由授权用户组的Oracle组，确保给Oracle服务器实用例程Oracle组ID，公用的可执行程序，比如SQL*Plus，SQL*forms等，应该可被这组执行，然后该这个实用例程的权限为710，它将允许同组的用户执行，而其他用户不能。

　　(3)改那些不会影响数据库安全性的程序的权限为711。(注:在我们的系统中为了安装和调试的方便，Oracle数据库中的两个具有DBA权限的用户Sys和System的缺省密码是manager。为了您数据库系统的安全，我们强烈建议您该掉这两个用户的密码，具体操作如下:

　　在SQL*DBA下键入:

　　alter user sys indentified by password;

　　alter user system indentified by password;

　　其中password为您为用户设置的密码。

　　·Oracle服务器实用例程的安全性:

　　以下是保护Oracle服务器不被非法用户使用的几条建议:

　　(1) 确保$ORACLE_HOME/bin目录下的所有程序的拥有权归Oracle软件拥有者所有;

　　(2) 给所有用户实用便程(sqiplus,sqiforms,exp,imp等)711权限，使服务器上所有的用户都可访问Oracle服务器;

　　(3) 给所有的DBA实用例程(比如SQL*DBA)700权限。Oracle服务器和Unix组当访问本地的服务时，您可以通过在操作系统下把Oracle服务器的角色映射到Unix的组的方式来使用Unix管理服务器的安全性，这种方法适应于本地访问。

　　在Unix中指定Oracle服务器角色的格式如下:

　　ora_sid_role[_dla]

　　其中 sid 是您Oracle数据库的oracle_sid;

　　role 是Oracle服务器中角色的名字;

　　d (可选)表示这个角色是缺省值;a (可选)表示这个角色带有WITH ADMIN选项，您只可以把这个角色授予其他角色，不能是其他用户。

　　以下是在/etc/group文件中设置的例子:

　　ora_test_osoper_d:NONE:1:jim,narry,scott

　　ora_test_osdba_a:NONE:3:pat

　　ora_test_role1:NONE:4:bob,jane,tom,mary,jim

　　bin: NONE:5:root,oracle,dba

　　root:NONE:7:root

　　词组“ora_test_osoper_d”表示组的名字;词组“NONE”表示这个组的密码;数字1表示这个组的ID;接下来的是这个组的成员。前两行是Oracle服务器角色的例子，使用test作为sid，osoper和osdba作为Oracle服务器角色的名字。osoper是分配给用户的缺省角色，osdba带有WITH ADMIN选项。为了使这些数据库角色起作用，您必须shutdown您的数据库系统，设置Oracle数据库参数文件initORACLE_SID.ora中os_roles参数为True，然后重新启动您的数据库。如果您想让这些角色有connect internal权限，运行orapwd为这些角色设置密码。当您尝试connect internal时，您键入的密码表示了角色所对应的权限。

　　·SQL*DBA命令的安全性:

　　如果您没有SQL*PLUS应用程序，您也可以使用SQL*DBA作SQL查权限相关的命令只能分配给Oracle软件拥有者和DBA组的用户，因为这些命令被授予了特殊的系统权限。

　　(1) startup

　　(2) shutdown

　　(3) connect internal

　　·数据库文件的安全性:

　　Oracle软件的拥有者应该这些数据库文件($ORACLE_HOME/dbs/*.dbf)设置这些文件的使用权限为0600:文件的拥有者可读可写，同组的和其他组的用户没有写的权限。

　　Oracle软件的拥有者应该拥有包含数据库文件的目录，为了增加安全性，建议收回同组和其他组用户对这些文件的可读权限。

　　·网络安全性:

　　当处理网络安全性时，以下是额外要考虑的几个问题。

　　(1) 在网络上使用密码在网上的远端用户可以通过加密或不加密方式键入密码，当您用不加密方式键入密码时，您的密码很有可能被非法用户截获，导致破坏了系统的安全性。

　　(2) 网络上的DBA权限控制您可以通过下列两种方式对网络上的DBA权限进行控制:

　　A 设置成拒绝远程DBA访问;

　　B 通过orapwd给DBA设置特殊的密码。

　　·建立安全性策略:

　　系统安全性策略

　　(1)管理数据库用户:数据库用户是访问Oracle数据库信息的途径，因此，应该很好地维护管理数据库用户的安全性。按照数据库系统的大小和管理数据库用户所需的工作量，数据库安全性管理者可能只是拥有create，alter，或drop数据库用户的一个特殊用户，或者是拥有这些权限的一组用户，应注意的是，只有那些值得信任的个人才应该有管理数据库用户的权限。

　　(2) 用户身份确认:数据库用户可以通过操作系统，网络服务，或数据库进行身份确认，通过主机操作系统进行用户身份认证的优点有:

　　A 用户能更快，更方便地联入数据库;

　　B 通过操作系统对用户身份确认进行集中控制:如果操作系统与数据库用户信息一致，Oracle无须存储和管理用户名以及密码;

　　C 用户进入数据库和操作系统审计信息一致。

　　(3) 操作系统安全性

　　A 数据库管理员必须有create和delete文件的操作系统权限;

　　B 一般数据库用户不应该有create或delete与数据库相关文件的操作系统权限;

　　C 如果操作系统能为数据库用户分配角色，那么安全性管理者必须有修改操作系统帐户安全性区域的操作系统权限。

　　·数据的安全性策略:

　　数据的生考虑应基于数据的重要性。如果数据不是很重要，那么数据的安全性策略可以稍稍放松一些。然而，如果数据很重要，那么应该有一谨慎的安全性策略，用它来维护对数据对象访问的有效控制。

　　·用户安全性策略:

　　(1) 一般用户的安全性:

　　A 密码的安全性:如果用户是通过数据库进行用户身份的确认，那么建议使用密码加密的方式与数据库进行连接。这种方式的设置方法如下:

　　在客户端的oracle.ini文件中设置ora_encrypt_login数为true;

　　在服务器端的initORACLE_SID.ora文件中设置dbling_encypt_login参数为true。

　　B 权限管理:对于那些用户很多，应用程序和数据对象很丰富的数据库，应充分利用“角色”这个机制所带的方便性对权限进行有效管理。对于复杂的系统环境，“角色”能大大地简化权限的理。

　　(2) 终端用户的安全性:

　　您必须针对终端用户制定安全性策略。例如，对于一个有很多用户的大规模数据库，安全性管理者可以决定用户组分类为这些用户组创建用户角色，把所需的权限和应用程序角色授予每一个用户角色，以及为用户分配相应的用户角色。当处理特殊的应用要求时，安全性管理者也必须明确地把一些特定的权限要求授予给用户。您可以使用“角色”对终端用户进行权限管理。

　　·数据库管理者安全性策略:

　　(1) 保护作为sys和system用户的连接:

　　当数据库创建好以后，立即更改有管理权限的sys和system用户的密码，防止非法用户访问数据库。当作为sys和system用户连入数据库后，用户有强大的权限用各种方式对数据库进行改动。

　　(2) 保护管理者与数据库的连接:

　　应该只有数据库管理者能用管理权限连入数据库，当以sysdba或startup，shutdown，和recover或数据库对象(例如create,drop，和delete等)进行没有任何限制的操作。

　　(3) 使用角色对管理者权限进行管理

　　·应用程序开发者的安全性策略:

　　(1) 应用程序开发者和他们的权限数据库应用程序开发者是唯一一类需要特殊权限组完成自己工作的数据库用户。开发者需要诸如create table,create，procedure等系统权限，然而，为了限制开发者对数据库的操作，只应该把一些特定的系统权限授予开发者。

　　(2) 应用程序开发者的环境:

　　A 程序开发者不应与终端用户竞争数据库资源;

　　B 用程序开发者不能损害数据库其他应用产品。

　　(3) free和controlled应用程序开发应用程序开发者有一下两种权限:

　　A free development

　　应用程序开发者允许创建新的模式对象，包括table,index,procedure,package等，它允许应用程序开发者开发独立于其他对象的应用程序。

　　B controlled development

　　应用程序开发者不允许创建新的模式对象。所有需要table,indes procedure等都由数据库管理者创建，它保证了数据库管理者能完全控制数据空间的使用以及访问数据库信息的途径。但有时应用程序开发者也需这两种权限的混和。

　　(4) 应用程序开发者的角色和权限数据库安全性管理者能创建角色来管理典型的应用程序开发者的权限要求。

　　A create系统权限常常授予给应用程序开发者，以至于他们能创建他的数据对象。

　　B 数据对象角色几乎不会授予给应用程序开发者使用的角色。

　　(5) 加强应用程序开发者的空间限制作为数据库安全性管理者，您应该特别地为每个应用程序开发者设置以下的一些限制:

　　A 开发者可以创建table或index的表空间;

　　B 在每一个表空间中，开发者所拥有的空间份额。应用程序管理者的安全在有许多数据库应用程序的数据库系统中，您可能需要一应用程序管理者，应用程序管理者应负责起以下的任务:

　　a)为每一个应用程序创建角色以及管理每一个应用程序的角色;

　　b)创建和管理数据库应用程序使用的数据对象;

　　c)需要的话，维护和更新应用程序代码和Oracle的存储过程和程序包。

　　我相信有了以上的这些建议，作为一个Oracle的管理者绝对可以做好他本职的工作了。可是，我们再怎么努力，都始终得面对这样一个现实，那就是Oracle毕竟是其他人开发的，而我们却在使用。所以，Oracle到底有多少漏洞--我想这个不是你和我所能解决的。不过既然作为一篇讨论Oracle数据安全的文章，我认为有必要把漏洞这一块也写进去，毕竟这也是“安全”必不可少的一部分。呵呵!

　　所以……

　　【Oracle漏洞举例】:

　　·Oracle9iAS Web Cache远程拒绝服务攻击漏洞(2002-10-28)

　　·Oracle 8.1.6的oidldapd中的漏洞

　　·Oracle 9iAS OracleJSP 泄漏JSP文件信息漏洞

　　·Linux ORACLE 8.1.5漏洞

　　想必我没有理由再往下举了，因为读者肯定已经从其他有效的途径得到了关于Oracle漏洞的最新情报。我这里就不再赘述了。

　　总而言之一句话--“Oracle数据安全是一个博大而又精深的话题;如果你没有耐心，就永远不会得到它的精髓之所在。”

　　问:我现在有sybase数据库开发的软件,想把sybase数据库中的数据导入到利用oracle数据库开发的软件中?如果可以,是不是在开发oracle数据库(现在基于oracle的数据库还没有开发)的时候有什么特别要求?

　　答:1、简单的办法，是将sybase中的数据导成SQL 语句，然后针对可能不同的数据类型做一些修改。或者将数据导成文本，使用分隔符隔离，然后使用ORACLE的sqlldr导入。

　　    2、或者使用一些现成的工具，有些可以试用，你可以看看。
http://www.swissql.com/products/sybase-to-oracle/sybase-to-oracledownloadform.html

　　1. 自动增长的数据类型处理

　　MYSQL有自动增长的数据类型，插入记录时不用操作此字段，会自动获得数据值。ORACLE没有自动增长的数据类型，需要建立一个自动增长的序列号，插入记录时要把序列号的下一个值赋于此字段。

　　CREATE SEQUENCE 序列号的名称 (最好是表名+序列号标记) INCREMENT BY 1 STARTWITH 1 MAXVALUE 99999 CYCLE NOCACHE;

　　其中最大的值按字段的长度来定, 如果定义的自动增长的序列号 NUMBER(6) , 最大值为999999

　　INSERT 语句插入这个字段值为: 序列号的名称.NEXTVAL

　　2. 单引号的处理

　　MYSQL里可以用双引号包起字符串，ORACLE里只可以用单引号包起字符串。在插入和修改字符串前必须做单引号的替换:把所有出现的一个单引号替换成两个单引号。

　　3. 翻页的SQL语句的处理

　　MYSQL处理翻页的SQL语句比较简单，用LIMIT 开始位置, 记录个数;PHP里还可以用SEEK定位到结果集的位置。ORACLE处理翻页的SQL语句就比较繁琐了。每个结果集只有一个ROWNUM字段标明它的位置, 并且只能用ROWNUM<100, 不能用ROWNUM>80。

　　以下是经过分析后较好的两种ORACLE翻页SQL语句( ID是唯一关键字的字段名 ):

　　语句一:

　　SELECT ID, [FIELD_NAME,...] FROM TABLE_NAME WHERE ID IN ( SELECT ID FROM (SELECT ROWNUM AS NUMROW, ID FROM TABLE_NAME WHERE 条件1 ORDER BY 条件2) WHERE NUMROW > 80 AND NUMROW < 100 ) ORDER BY 条件3;

　　语句二:

　　SELECT * FROM (( SELECT ROWNUM AS NUMROW, c.* from (select [FIELD_NAME,...] FROM TABLE_NAME WHERE 条件1 ORDER BY 条件2) c) WHERE NUMROW > 80 AND NUMROW < 100 ) ORDER BY 条件3;

　　4. 长字符串的处理

　　长字符串的处理ORACLE也有它特殊的地方。INSERT和UPDATE时最大可操作的字符串长度小于等于4000个单字节, 如果要插入更长的字符串, 请考虑字段用CLOB类型，方法借用ORACLE里自带的DBMS_LOB程序包。插入修改记录前一定要做进行非空和长度判断，不能为空的字段值和超出长度字段值都应该提出警告,返回上次操作。

　　5. 日期字段的处理

　　MYSQL日期字段分DATE和TIME两种，ORACLE日期字段只有DATE，包含年月日时分秒信息，用当前数据库的系统时间为SYSDATE, 精确到秒，或者用字符串转换成日期型函数TO_DATE(‘2001-08-01’,’YYYY-MM-DD’)年-月-日 24小时:分钟:秒 的格式YYYY-MM-DD HH24:MI:SS TO_DATE()还有很多种日期格式, 可以参看ORACLE DOC.日期型字段转换成字符串函数TO_CHAR(‘2001-08-01’,’YYYY-MM-DD HH24:MI:SS’)

　　日期字段的数学运算公式有很大的不同。MYSQL找到离当前时间7天用 DATE_FIELD_NAME > SUBDATE(NOW()，INTERVAL 7 DAY)ORACLE找到离当前时间7天用 DATE_FIELD_NAME >SYSDATE - 7;

　　6. 空字符的处理

　　MYSQL的非空字段也有空的内容，ORACLE里定义了非空字段就不容许有空的内容。按MYSQL的NOT NULL来定义ORACLE表结构, 导数据的时候会产生错误。因此导数据时要对空字符进行判断，如果为NULL或空字符，需要把它改成一个空格的字符串。

　　7. 字符串的模糊比较

　　MYSQL里用 字段名 like '%字符串%',ORACLE里也可以用 字段名 like '%字符串%' 但这种方法不能使用索引, 速度不快，用字符串比较函数 instr(字段名,'字符串')>0 会得到更精确的查找结果。

　　8. 程序和函数里，操作数据库的工作完成后请注意结果集和指针的释放。

　 2.    特别为计算建立函数索引

    3.    将计算从等号左边移到右边
　这是针对某些无心之失的纠正，把a*2>4　改为a>4/2；把TO_CHAR(zip) = '94002' 改为zip = TO_NUMBER('94002');

3.2 CBO与索引选择性
     建了索引也不一定会被Oracle用的，就像个挑食的孩子。基于成本的优化器(CBO, Cost-Based Optimizer)，会先看看表的大小，还有索引的重复度，再决定用还是不用。表中有100 条记录而其中有80 个不重复的索引键值. 这个索引的选择性就是80/100 = 0.8，留意Toad里显示索引的Selective和Cardinailty。实在不听话时，就要用hints来调教。
     另外，where语句存在多条索引可用时，只会选择其中一条。所以索引也不是越多越好：）

3.3 索引重建
     传说中数据更新频繁导致有20%的碎片时，Oracle就会放弃这个索引。宁可信其有之下，应该时常alter index <INDEXNAME> rebuild一下。

3.4 其他要注意的地方
      不要使用Not，如goods_no != 2，要改为

      不要使用is null , 如WHERE DEPT_CODE IS NOT NULL 要改为

3.5 select 的列如果全是索引列时
   又如果没有where 条件，或者where条件全部是索引列时，Oracle 将直接从索引里获取数据而不去读真实的数据表，这样子理论上会快很多，比如

当order_no,order_time,shop_no 这三列全为索引列时，你将看到一个和平时完全不同的执行计划。

3.6 位图索引
     传说中当数据值较少，比如某些表示分类、状态的列，应该建位图索引而不是普通的二叉树索引，否则效率低下。不过看执行计划，这些位图索引鲜有被Oracle临幸的。
 

4.减少查询往返和查询的表
这也是很简单的大道理，程序与Oracle交互的成本极高，所以一个查询能完成的不要分开两次查，如果一个循环执行１万条查询的，怎么都快不到哪里去了。

4.1 封装PL/SQL存储过程
　 最高级的做法是把循环的操作封装到PL/SQL写的存储过程里，因为存储过程都在服务端执行，所以没有数据往返的消耗。

4.2 封装PL/SQL内部函数
  有机会，将一些查询封装到函数里，而在普通SQL里使用这些函数，同样是很有效的优化。

4.3 Decode/Case
　 但存储过程也麻烦，所以有case/decode把几条条件基本相同的重复查询合并为一条的用法：

4.4 一种Where/Update语法

5.其他优化
5.1RowID和ROWNUM
     连Hibernate 新版也支持ROWID了，证明它非常有用。比如号称删除重复数据的最快写法：

6.终极秘技 - Hints
   这是Oracle DBA的玩具，也是终极武器，比如Oracle在CBO,RBO中所做的选择总不合自己心水时，可以用它来强力调教一下Oracle，结果经常让人喜出望外。
   如果开发人员没那么多时间来专门学习它，可以依靠Toad SQL opmitzer 来自动生成这些提示，然后对比一下各种提示的实际效果。不过随着10g智能的进化，hints的惊喜少了。

7. 找出要优化的Top SQL
    磨了这么久的枪，如果找不到敌人是件郁闷的事情。
    幸亏10g这方面做得非常好。进入Web管理界面，就能看到当前或者任意一天的SQL列表，按性能排序。
    有了它，SQL Trace和TKPROF都可以不用了。

    SELECT语句用于从数据库中查询数据，当在PL/SQL中使用SELECT语句时，要与INTO子句一起使用，查询的返回值被赋予INTO子句中的变量，变量的声明是在DELCARE中。SELECT             INTO语法如下： 

     SELECT [DISTICT|ALL]{*|column[,column,...]} 

     INTO (variable[,variable,...] |record) 

     FROM {table|(sub-query)}[alias] 

     WHERE............ 

    PL/SQL中SELECT语句只返回一行数据。如果超过一行数据，那么就要使用显式游标（对游标的讨论我们将在后面进行），INTO子句中要有与SELECT子句中相同列数量的变量。INTO子句中也可以是记录变量。 

%TYPE属性 

     在PL/SQL中可以将变量和常量声明为内建或用户定义的数据类型，以引用一个列名，同时继承他的数据类型和大小。这种动态赋值方法是非常有用的，比如变量引用的列的数据类型和大小改变了，如果使用了%TYPE,那么用户就不必修改代码，否则就必须修改代码。 

例： 

  v_empno SCOTT.EMP.EMPNO%TYPE; 

  v_salary EMP.SALARY%TYPE; 

  　不但列名可以使用%TYPE,而且变量、游标、记录，或声明的常量都可以使用%TYPE。这对于定义相同数据类型的变量非常有用。 

    DELCARE 

    V_A NUMBER(5):=10; 

    V_B V_A%TYPE:=15; 

    V_C V_A%TYPE; 

    BEGIN 

      DBMS_OUTPUT.PUT_LINE 

      ('V_A='||V_A||'V_B='||V_B||'V_C='||V_C); 

    END 

    SQL>/ 

    V_A=10 V_B=15 V_C= 

     PL/SQL procedure successfully completed. 

     SQL> 

其他DML语句 

    其它操作数据的DML语句是:INSERT、UPDATE、DELETE和LOCK TABLE,这些语句在PL/SQL中的语法与在SQL中的语法相同。我们在前面已经讨论过DML语句的使用这里就不再重复了。在DML语句中可以使用任何在DECLARE部分声明的变量，如果是嵌套块，那么要注意变量的作用范围。 

例： 

  CREATE OR REPLACE PROCEDURE FIRE_EMPLOYEE (pempno in number) 

  　AS 

    v_ename EMP.ENAME%TYPE; 

    BEGIN 

    　SELECT ename INTO v_ename 

      FROM emp 

      WHERE empno=p_empno; 

      INSERT INTO FORMER_EMP(EMPNO,ENAME) 

      VALUES (p_empno,v_ename); 

      DELETE FROM emp 

      WHERE empno=p_empno; 

      UPDATE former_emp 

      SET date_deleted=SYSDATE 

      WHERE empno=p_empno; 

    EXCEPTION 

       WHEN NO_DATA_FOUND THEN 

       DBMS_OUTPUT.PUT_LINE('Employee Number Not Found!'); 

    END 

DML语句的结果 

    当执行一条DML语句后，DML语句的结果保存在四个游标属性中，这些属性用于控制程序流程或者了解程序的状态。当运行DML语句时，PL/SQL打开一个内建游标并处理结果，游标是维护查询结果的内存中的一个区域，游标在运行DML语句时打开，完成后关闭。隐式游标只使用SQL%FOUND,SQL%NOTFOUND,SQL%ROWCOUNT三个属性.SQL%FOUND,SQL%NOTFOUND是布尔值，SQL%ROWCOUNT是整数值。 

SQL%FOUND和SQL%NOTFOUND 

    在执行任何DML语句前SQL%FOUND和SQL%NOTFOUND的值都是NULL,在执行DML语句后，SQL%FOUND的属性值将是： 

. TRUE :INSERT 

. TRUE :DELETE和UPDATE，至少有一行被DELETE或UPDATE. 

. TRUE :SELECT INTO至少返回一行 

当SQL%FOUND为TRUE时,SQL%NOTFOUND为FALSE。 

SQL%ROWCOUNT 

   在执行任何DML语句之前，SQL%ROWCOUNT的值都是NULL,对于SELECT             INTO语句，如果执行成功，SQL%ROWCOUNT的值为1,如果没有成功，SQL%ROWCOUNT的值为0，同时产生一个异常NO_DATA_FOUND. 

SQL%ISOPEN 

  SQL%ISOPEN是一个布尔值，如果游标打开，则为TRUE, 如果游标关闭，则为FALSE.对于隐式游标而言SQL%ISOPEN总是FALSE，这是因为隐式游标在DML语句执行时打开，结束时就立即关闭。 

事务控制语句 

    事务是一个工作的逻辑单元可以包括一个或多个DML语句，事物控制帮助用户保证数据的一致性。如果事务控制逻辑单元中的任何一个DML语句失败，那么整个事务都将回滚，在PL/SQL中用户可以明确地使用COMMIT、ROLLBACK、SAVEPOINT以及SET TRANSACTION语句。 

     COMMIT语句终止事务，永久保存数据库的变化，同时释放所有LOCK,ROLLBACK终止现行事务释放所有LOCK，但不保存数据库的任何变化,SAVEPOINT用于设置中间点，当事务调用过多的数据库操作时，中间点是非常有用的，SET TRANSACTION用于设置事务属性，比如read-write和隔离级等。 

显式游标 

    当查询返回结果超过一行时，就需要一个显式游标，此时用户不能使用select into语句。PL/SQL管理隐式游标，当查询开始时隐式游标打开，查询结束时隐式游标自动关闭。显式游标在PL/SQL块的声明部分声明，在执行部分或异常处理部分打开，取数据,关闭。 

使用游标 

    这里要做一个声明，我们所说的游标通常是指显式游标，因此从现在起没有特别指明的情况，我们所说的游标都是指显式游标。要在程序中使用游标，必须首先声明游标。 

声明游标 

语法： 

    CURSOR cursor_name IS select_statement; 

在PL/SQL中游标名是一个未声明变量，不能给游标名赋值或用于表达式中。 

例： 

    DELCARE 

    CURSOR C_EMP IS SELECT empno,ename,salary 

    FROM emp 

    WHERE salary>2000 

    ORDER BY ename; 

    ........ 

    BEGIN 

    在游标定义中SELECT语句中不一定非要表可以是视图，也可以从多个表或视图中选择的列，甚至可以使用*来选择所有的列 。 

　　一、Dos 环境下加载

　　1、首先，服务器端的侦听服务必须已经开启。

　　测试方法:Dos 下输入

　　C:\>sqlplus username/password@serviceName

　　2、然后使用 Oracle 的 sqlldr 命令进行数据的导入前期条件

　　1) Oracle 数据库端必须已经建好了需要导入的数据表的结构

　　2) 一个数据源文件 下面例子中为制表符分隔的文本文件 model.txt ,为Excel 表中导出的

　　3) 手工编辑一个XXX.CTL 的控制文件

　　4) 命令行加载数据

　　如下实例:

　　以下文件缺省放到C:\ 下，如果不是，就需要指明全路径

　　1. 命令控制文件 input.ctl 内容

　　命令

　　说明

　　load data

　　1、控制文件标识

　　infile 'model.txt'

　　2、要输入的数据文件名为test.txt

　　append into table system.塔位属性表

　　3、向表test中追加记录

　　fields terminated by X'09'

　　4、指定分隔符，字段终止于X'09'，是一个制表符(TAB)

　　(编号,名称,大小)

　　5、定义列对应表中顺序

　　控制文件中指定插入数据的方式关键字

　　l insert，为缺省方式，在数据装载开始时要求表为空

　　l append，在表中追加新记录

　　l replace，删除旧记录，替换成新装载的记录

　　l truncate，同上

　　在 Dos 窗口下使用 SQl*Loader 命令实现数据的导入

　　C:\>sqlldr userid=system/manager@ serviceName control=input.ctl

　　默认日志文件名为:input.log

　　默认坏记录文件为:input.bad

　　二、使用其它数据库转移工具

　　以下以SQL Server 导入导出向导为例

　　1、在数据的导入导出向导中设置数据源服务器，实例中选择数据源选择SQL Server

　　2、然后指定要导入的Oracle 数据源

　　3、需要配置Oracle 的属性信息

　　需要注意的是，登录数据库的用户信息即为数据导入之后的方案名，即导入之后的SQL Server 中的表在Oracle 中标志名为 username.表名

　　以下按照提示即可，可以完全导入SQl Server 中的数据表和视图，也可以使用查询语句返回你要选择的列或者行。

　　三、Oracle 企业管理器中的数据加载功能

　　登录Oracle 的控制台界面，针对单独的数据表可以使用数据加载工具

　　中间需要指定控制文件等，同Dos 加载一致，不再重复

Informix SQL函数的详细用法

一、内部函数
　 1、内部合计函数
　　　 1）COUNT（*）　　　　　　　　　　返回行数
　　　 2）COUNT（DISTINCT COLNAME）　　 返回指定列中唯一值的个数
　　　 3）SUM（COLNAME/EXPRESSION）　　 返回指定列或表达式的数值和；
　　　 4）SUM（DISTINCT COLNAME）　　　 返回指定列中唯一值的和
　　　 5）AVG（COLNAME/EXPRESSION）　　 返回指定列或表达式中的数值平均值
　　　 6）AVG（DISTINCT COLNAME）　　　 返回指定列中唯一值的平均值
　　　 7）MIN（COLNAME/EXPRESSION）　　 返回指定列或表达式中的数值最小值
　　　 8）MAX（COLNAME/EXPRESSION）　　 返回指定列或表达式中的数值最大值
　 2、日期与时间函数
　　　 1）DAY（DATE/DATETIME EXPRESSION）　　　返回指定表达式中的当月几号
　　　 2）MONTH（DATE/DATETIME EXPRESSION）　　返回指定表达式中的月份
　　　 3）YEAR（DATE/DATETIME EXPRESSION）　　 返回指定表达式中的年份
　　　 4）WEEKDAY（DATE/DATETIME EXPRESSION）　返回指定表达式中的当周星期几
　　　 5）DATE（NOT DATE EXPRESSION）　　　　　返回指定表达式代表的日期值
　　　 6）TODAY　　　　　　　　　　　　　　　　返回当前日期的日期值
　　　 7）CURRENT[first to last]　　　　　　　 返回当前日期的日期时间值
　　　 8）COLNAME/EXPRESSION UNITS PRECISION　 返回指定精度的指定单位数
　　　 9）MDY（MONTH，DAY，YEAR）　　　　　　　返回标识指定年、月、日的日期值
　　　 10）DATETIME（DATE/DATETIME EXPRESSION）FIRST TO LAST 返回表达式代表的日期时间值
　　　 11）INTERVAL（DATE/DATETIME EXPRESSION）FIRST TO LAST 返回表达式代表的时间间隔值
　　　 12）EXTEND（DATE/DATETIME EXPRESSION，[first to last]）返回经过调整的日期或日期时间

值

　　　 例子1、和UNITS合用，指定日期或时间单位(year,month,day,hour,minute,seond,fraction)：
　　　　　　　let tmp_date = today + 3 UNITS day
　　　 例子2、let tmp_date = MDY(10,30,2002)　　-- 2002-10-30
　　　 例子3、let tmp_date = today + interval(7) day to day　--当前时间加上7天；
　　　　　　　注：该功能与1相似；
　　　 例子4、EXTEND转换日期或日期时间值
　　　　　　　let tmp_inthour = extend(datetime1,hour to hour)

　 3、代数函数
　　　1）ABS(COLNAME/EXPRESSION)：　　　　　　 取绝对值
　　　2）MOD（COLNAME/EXPRESSION，DIVISOR）　　返回除以除数后的模（余数）
　　　3）POW（COLNAME/EXPRESSION，EXPONENT）　 返回一个值的指数冥
　　　　 例子：let tmp_float = pow(2,3)　--8.00000000

　　　4）ROOT（COLNAME/EXPRESSION，[index]）　 返回指定列或表达式的根值

　　　5）SQRT（COLNAME/EXPRESSION）　　　　　　返回指定列或表达式的平方根值

　　　6）ROUND（COLNAME/EXPRESSION，[factor]） 返回指定列或表达式的圆整化值
　　　7）TRUNC（COLNAME/EXPRESSION，[factor]） 返回指定列或表达式的截尾值
　　　　 说明：上两者中FACTOR指定小数位数，若不指定，则为0；若为负数，则整化到小数点左边；
　　　　 注：ROUND是在指定位上进行4舍5入；TRUNC是在指定位上直接截断；
　　　　　let tmp_float = round(4.555,2) --4.56
　　　　　let tmp_float = trunc(4.555,2) --4.55

　 4、指数与对数函数
　　　1）EXP（COLNAME/EXPRESSION）　　　　返回指定列或表达式的指数值
　　　2）LOGN（COLNAME/EXPRESSION）　　　 返回指定列或表达式的自然对数值
　　　3）LOG10（COLNAME/EXPRESSION）　　　返回指定列或表达式的底数位10的对数值

　 5、三角函数
　　　1）COS（RADIAN EXPRESSION）　　　　　返回指定弧度表达式的余弦值
　　　2）SIN（RADIAN EXPRESSION）　　　　　正弦
　　　3）TAN（RADIAN EXPRESSION）　　　　　正切
　　　4）ACOS（RADIAN EXPRESSION）　　　　 反余弦
　　　5）ASIN（RADIAN EXPRESSION）　　　　 反正弦
　　　6）ATAN（RADIAN EXPRESSION）　　　　 反正切
　　　7）ATAN2（X，Y）　　　　　　　　　　 返回坐标（X，Y）的极坐标角度组件

　 6、统计函数
　　　1）RANGE（COLNAME）　　　 返回指定列的最大值与最小值之差 = MAX（COLNAME）-MIN

（COLNAME）
　　　2）VARIANCE（COLNAME）　　返回指定列的样本方差；
　　　3）STDEV（COLNAME）　　　 返回指定列的标准偏差；

　 7、其他函数
　　　1）USER　　　　　　　　　　　　　　返回当前用户名
　　　2）HEX（COLNAME/EXPRESSION）　　　 返回指定列或表达式的十六进制值
　　　3）LENGTH（COLNAME/EXPRESSION）　　返回指定字符列或表达式的长度
　　　4）TRIM（COLNAME/EXPRESSION）　　　删除指定列或表达式前后的字符
　　　5）COLNAME/EXPRESSION || COLNAME/EXPRESSION　返回并在一起的字符；

二、IDS内部函数
　 1、DBSERVERNAME　　　返回数据库服务器名　let tmp_char=DBSERVERNAME
　 2、SITENAME　　　　　返回数据库服务器名　let tmp_char=SITENAME
　　　说明：两者功能相同；

　 3、DBINFO（‘SPECIAL_KEYWORD')　　　返回只关键字值
　　　例子1：返回数据中每个表的DBSPACE名称
　　　　 select dbinfo('dbspace',partnum),tabname from systables
　　　　　where tabid>99 and tabtype='T'　(OK)
　　　例子2：返回任何表中插入的最后一个SERIAL值
　　　　　select dbinfo('sqlca.sqlerrd1') from systables where tabid = 1
　　　例子3：返回最后一个SELECT，INSERT，UPDATE，DELETE或EXECUTE PROCEDURE语句处理的行数；
　　　　　select dbinfo('sqlca.sqlerrd2') from systables where tabid=1;