database.java

Oracle源码：Oracle 数据库管理与应用系统开发代码

			}
			Statement stmt = rs.getStatement(); 
			rs.close();
			if(stmt!=null)
				stmt.close();
	System.out.println("____"+vect);
		}
		catch(SQLException sqle){Logger.log(sqle,"调用DataBase.getTableStruct()函数错误:\r\n");}
		catch(AbstractMethodError e){Logger.log(e,"调用DataBase.getTableStruct()函数错误:\r\n");}
		return vect;
	}

	/**取得数据集内容*/
	public Vector getResultSetData(ResultSet rs)
	{
		Vector vect = new Vector();
		try
		{
			//取得列数和列名
			ResultSetMetaData rsmd = rs.getMetaData();
			int cols = rsmd.getColumnCount();
			while(rs.next())
			{	
				Hashtable hash = new Hashtable();
				for(int i=1;i<=cols;i++)
				{
					DealString ds = new DealString();
					String field = ds.toString(rsmd.getColumnName(i));
					String value = ds.toString(rs.getString(i));
					hash.put(field,value);
				}
				vect.add(hash);
			}
		}
		catch(SQLException sqle){Logger.log(sqle,"调用DataBase.getResultSetData()函数错误:\r\n");}
		return vect;
	}

	/**创建申明对象*/
	public void prepareStatement(String sql)
	{
		try
		{
			pstm = conn.prepareStatement(sql);
		}
		catch(SQLException sqle){Logger.log(sqle,"调用DataBase.prepareStatement()函数错误:\r\n");}
	}

	/**执行查询*/
	public void executeQuery()
	{
		try
		{
			rs = pstm.executeQuery();
		}
		catch(SQLException sqle){Logger.log(sqle,"调用DataBase.executeQuery()函数错误:\r\n");}
	}

	/**转向下一条*/
	public boolean next()
	{
		try
		{
			return rs.next();
		}
		catch(SQLException sqle){Logger.log(sqle,"调用DataBase.next()函数错误:\r\n");}
		return true;
	}

	/**取得数据并根据数据类型转化为字符串*/
	public String getObject(String field,String sqlType)
	{
		try
		{
			if(rs==null)return "";
			if(sqlType.equals("BINARY")||sqlType.equals("VARBINARY"))//字节型
			{
				byte b[] = rs.getBytes(field);
				return new String(b);
			}
			else if(sqlType.equals("LONGVARBINARY")||sqlType.equals("BLOB"))//未编码大字节型
			{
				InputStream is = rs.getBinaryStream(field);
				return (new DealFile()).readCHStr(is);
			}
			else if(sqlType.equals("LONGVARCHAR")||sqlType.equals("CLOB"))//编码大字节型
			{
				InputStream is = rs.getAsciiStream(field);
				return (new DealFile()).readCHStr(is);
			}
			else//字符串型
			{
				return rs.getString(field);
			}
		}
		catch(Exception sqle){Logger.log(sqle,"调用DataBase.getObject()函数错误:\r\n");}
		return "";
	}

	/**根据数据类型保存到数据库*/
	public void setObject(int index,String value,String sqlType)
	{
		try
		{
			if(sqlType.equals("ARRAY"))//数组型?????
			{
			}
			else if(sqlType.equals("BIGINT"))//64位的有符号整数
			{
				Long l = new Long(value);
				pstm.setObject(index,l);		
			}
			else if(sqlType.equals("BINARY")||sqlType.equals("VARBINARY"))//字节型
			{
				byte b[] = value.getBytes();
				pstm.setObject(index,b);
			}
			else if(sqlType.equals("BIT"))//布尔型
			{
				Boolean b = new Boolean("true");
				if(value.equals("0"))b = new Boolean("false");
				pstm.setObject(index,b);
			}
			else if(sqlType.equals("BLOB")||sqlType.equals("LONGVARBINARY"))//未编码流类型
			{
				FileInputStream fis = (new DealFile()).toInputStream(value);
				pstm.setBinaryStream(index,fis,(int)(new File("tmp.txt")).length());
			}
			else if(sqlType.equals("CLOB")||sqlType.equals("LONGVARCHAR"))//编码流类型
			{
				FileInputStream fis = (new DealFile()).toInputStream(value);				
				pstm.setAsciiStream(index,fis,(int)(new File("tmp.txt")).length());
			}
			else if(sqlType.equals("BOOLEAN"))//????
			{
			}
			else if(sqlType.equals("CHAR")||sqlType.equals("VARCHAR"))//字符串型
			{
				pstm.setObject(index,value);
			}
			else if(sqlType.equals("DATALINK"))//????
			{
			}
			else if(sqlType.equals("DATE"))//日期型
			{
				int year = Integer.parseInt(value.substring(0,4));
				int month = Integer.parseInt(value.substring(5,7));
				int day = Integer.parseInt(value.substring(8,10));
				java.sql.Date d = new java.sql.Date(year,month,day);
				pstm.setObject(index,d);
			}
			else if(sqlType.equals("DECIMAL")||sqlType.equals("NUMERIC"))//固定精度十进制型
			{
				java.math.BigDecimal b = new java.math.BigDecimal(value);
				pstm.setObject(index,b);
			}
			else if(sqlType.equals("DISTINCT"))//????
			{
			}
			else if(sqlType.equals("DOUBLE")||sqlType.equals("FLOAT"))//双精度浮点型
			{
				Double d = new Double(value);
				pstm.setObject(index,d);
			}
			else if(sqlType.equals("INTEGER"))//32位的有符号整数
			{
				Integer i = new Integer(value);
				pstm.setObject(index,i);
			}
			else if(sqlType.equals("JAVA_OBJECT"))//????
			{
			}
			else if(sqlType.equals("NULL"))//????
			{
			}
			else if(sqlType.equals("OTHER"))//????
			{
			}
			else if(sqlType.equals("REAL"))//单精度浮点型
			{
				Float f = new Float(value);
				pstm.setObject(index,f);
			}
			else if(sqlType.equals("REF"))//????
			{
			}
			else if(sqlType.equals("SMALLINT"))//16位的有符号整数
			{
				Short s = new Short(value);
				pstm.setObject(index,s);
			}
			else if(sqlType.equals("STRUCT"))//????
			{
			}
			else if(sqlType.equals("TIME"))//时间型
			{
				int hour = Integer.parseInt(value.substring(0,2));
				int minute = Integer.parseInt(value.substring(3,5));
				int second = Integer.parseInt(value.substring(6,8));
				java.sql.Time t = new java.sql.Time(hour,minute,second);
				pstm.setObject(index,t);
			}
			else if(sqlType.equals("TIMESTAMP"))//日期时间型
			{
				int year = Integer.parseInt(value.substring(0,4));
				int month = Integer.parseInt(value.substring(5,7));
				int date = Integer.parseInt(value.substring(8,10));
				int hour = Integer.parseInt(value.substring(11,13));
				int minute = Integer.parseInt(value.substring(14,16));
				int second = Integer.parseInt(value.substring(17,19));
				int nano = Integer.parseInt(value.substring(20,21));
				java.sql.Timestamp t = new java.sql.Timestamp(year,month,date,hour,minute,second,nano);
				pstm.setObject(index,t);
			}
			else if(sqlType.equals("TINYINT"))//8位无符号整数
			{
				Byte b = new Byte(value);
				pstm.setObject(index,b);
			}
		}
		catch(Exception sqle){Logger.log(sqle,"调用DataBase.setObject()函数错误:\r\n");}
	}

	/**执行更新*/
	public void executeUpdate()
	{
		try
		{
			pstm.executeUpdate();
		}
		catch(SQLException sqle){Logger.log(sqle,"调用DataBase.executeUpdate()函数错误:\r\n");}
	}

	/**关闭申明对象*/
	public void closePstm()
	{
		if ( pstm != null ) 
		try
		{
			pstm.close();
		}
		catch(SQLException sqle){Logger.log(sqle,"调用DataBase.closePstm()函数错误:\r\n");}
	}

	/**关闭游标*/
	public void closeRs()
	{
		if ( rs != null )
		try
		{
			rs.close();
		}
		catch(SQLException sqle){Logger.log(sqle,"调用DataBase.closeRs()函数错误:\r\n");}
	}


	public void test() throws Exception
	{
		PreparedStatement pstm = conn.prepareStatement("update test set name=?,time=?,d=?,bb=?");
		java.sql.Time d = new java.sql.Time(20031011);
		pstm.setObject(1,"fdafafdsa");
		Boolean b = new Boolean(true);
		pstm.setObject(2,b);
		pstm.setObject(3,d);
		pstm.setObject(4,(new String("testlzb")).getBytes());
		pstm.executeUpdate();
		pstm.close();
		
		ResultSet rs = QuerySQL("select * from test");
		while(rs.next())
		{
			//System.out.println("1=="+new String(rs.getObject("bb")));
			//System.out.println("2=="+rs.getObject("bb").toString());
	System.out.println((String)rs.getObject("name"));
			Object o = rs.getObject("bb");
			String t = new String((byte[])o);
			byte bv[] = t.getBytes();
	System.out.println("____"+bv[0]);
			String s = new String(bv);
			System.out.println("t"+t);
			System.out.println("s"+s);
		}
		Statement stst = rs.getStatement(); 
		rs.close();if(stst!=null) stst.close();
//输出:getString()数字，字符串，日期,getBytes(),getBinaryStream()BLOB,getAsciiStream()CLOB
//均转化为字符串＊＊＊＊＊＊＊＊＊１
//对二进制，输出的均为转化后的字符串，在输入时反转换为二进制流，只要在输出时二进制流和输入时的二进制流一样就行
//检验Binary即可验证是否正确
//输入:setObject();构造相应的对象＊＊＊＊＊＊＊＊＊２


//输出：根据类型来确定使用那个函数(ParentBean)
		//正转：将流转换为字符串(DealFile)
//输入：根据类型来将字符串构造成不同的数据类型(ParentBean)
		//反转：将字符串转换为流(DealFile)





	}

	public void setBinaryStream(int index,InputStream is,int t) throws Exception
	{
		pstm.setBinaryStream(index,is,t);
	}

	public void setAsciiStream(int index,InputStream is,int t) throws Exception
	{
		pstm.setBinaryStream(index,is,t);
	}

	
	public boolean getAutoCommit()
	{
		try
		{
			return conn.getAutoCommit();
		}catch(SQLException e){}
		return true;
	}

	public void closeAutoCommit()
	{
		try
		{
			conn.setAutoCommit(false);
		}catch(SQLException e){}
	}
	
	public void commit()
	{
		try
		{
			conn.commit();
		}catch(SQLException e){}
	}
	
	public void rollback()
	{
		try
		{
			conn.rollback();
		}catch(SQLException e){}
	}

	public void openAutoCommit()
	{
		try
		{
			conn.setAutoCommit(true);
		}catch(SQLException e){}
	}

	public void createStatement()
	{
		try
		{
			stm = conn.createStatement();
		}catch(SQLException e){}
	}

	public void clearBatch()
	{
		try
		{
			stm.clearBatch();
		}catch(SQLException e){}
	}

	public void addBatch(String sql)
	{
		try
		{
			stm.addBatch(sql);
		}catch(SQLException e){}
	}
	public int[] executeBatch()
	{
		try
		{
			return stm.executeBatch();
		}catch(SQLException e){}
		return null;
	}

	public void closeStm()//专门使用	
	{
		if(stm!=null)
		try
		{
			stm.close();
		}catch(SQLException e){}
	}
};