通过hibernate操作oracle的clob类型数据
hibernate内部测试题总结
hibernate内部测试题总结在Hibernate中,关于脏检查和刷新缓存说法正确的是(ab )。
A.当事务提交时,会发⽣脏检查B.Session的flush( )⽅法是刷新缓存的⽅法C.在执⾏Session的commit( )⽅法之前不会调⽤Session的flush( )⽅法D.编写代码时,调⽤commit( )⽅法之前要调⽤flush( )⽅法解析:在执⾏Session的commit()⽅法之前会调⽤Session的flush()⽅法 C错误 调⽤commit()⽅法都不是⼿动调⽤flush()⽅法使⽤HQL查询所有部门信息,以下正确的是( b)。
A.from DeptB.select * from cn.jbit.demo.entity.DeptC.select Dept from cn.jbit.demo.entity.Dept dD.select d from Dept d解析:HQL查询信息没有 *关于Query接⼝的list( )和iterate( )⽅法,说法正确的是( ad)。
A.执⾏list( )⽅法,查询所有符合条件的记录B.执⾏iterate( )⽅法,查询所有符合条件的记录C.执⾏list( )⽅法,查询出所有符合条件的主键值D.执⾏iterate ( )⽅法,查询出所有符合条件的主键值解析:list()是查询⼿游符合条件的记录 iterate()是查询出所有符合条件的5.在HQL中,关于Query接⼝绑定参数的⽅法,说法正确的是( ABCD)。
A.setParameter( )⽅法⽤于绑定任意类型的参数B.setParameter( )有重载的⽅法C.setProperties( )有重载的⽅法D.setProperties( )⽅法⽤于绑定命名参数6.在Hibernate中,关于以下映射配置,说法错误的是(D)。
<hibernate-mapping><class name="cn.jbit.hibernatedemo.entity.Emp" table="EMP" schema="scott"> <id name="empNo" column="EMPNO" type="ng.Integer"><generator class="assigned"/></id><property name="salary" type="ng.Double" column="SAL"/><property name="hireDate" type="java.util.Date"/><many-to-onename="dept"column="DEPTNO"class="cn.jbit.hibernatedemo.entity.Dept"/></class></hibernate-mapping>A.此配置信息描述了cn.jbit.hibernatedemo.entity.Emp类和EMP表的映射B.描述的是scott⽤户的EMP表C.<many-to-one>标签中的name属性值dept是cn.jbit.hibernatedemo.entity.Emp类的属性名D.<many-to-one>标签中的column属性值DEPTNO是dept表的主键名解析:D选项中column属性值deptNo是emp表中的外键列7.在Hibernate映射⽂件中,关于inverse属性说法正确的是(ACD)。
oracle select clob字段内容-概述说明以及解释
oracle select clob字段内容-概述说明以及解释1.引言1.1 概述CLOB字段(Character Large Object)是一种用于存储大文本数据的Oracle数据库字段类型。
在数据库中,通常将CLOB字段用于存储大于4000个字符的文本数据,例如长篇文章、日志信息、XML文档等。
本文将重点讨论如何在Oracle数据库中查询CLOB字段的内容。
通过有效地查询CLOB字段,我们可以轻松地获取和操作大文本数据,从而更好地满足业务需求。
接下来,我们将详细介绍Oracle中如何查询CLOB字段内容,以及在查询过程中需要注意的事项。
通过学习本文内容,读者将更加了解如何有效地处理CLOB字段数据,提高数据库查询和管理的效率。
1.2文章结构文章结构部分主要介绍了本文的整体结构和内容安排。
首先,我们将引言部分介绍本文的背景和目的,引导读者了解本文的主题和意义。
接着,在正文部分我们将详细介绍什么是CLOB字段以及在Oracle中如何查询CLOB字段内容,同时提供查询过程中需要注意的事项。
最后,在结论部分我们将对本文进行总结,探讨CLOB字段的应用场景,以及展望未来可能的发展方向。
通过本文的结构安排,读者将能够全面了解和掌握如何查询Oracle中的CLOB字段内容。
1.3 目的:本文的目的在于帮助读者了解如何在Oracle数据库中查询CLOB字段的内容。
CLOB字段是一种专门用来存储大文本数据的字段类型,通常用于存储文档、日志、报告等内容较大的数据。
在实际应用中,我们经常需要查询CLOB字段的内容以便分析和处理,因此正确地查询和处理CLOB字段内容具有重要意义。
通过本文的阐述,读者将能够清楚地了解什么是CLOB字段、如何准确地查询CLOB字段内容以及在查询过程中需要注意的事项。
希望读者在阅读完本文后能够掌握查询CLOB字段内容的技巧,提高数据处理的效率和准确性。
2.正文2.1 什么是CLOB字段CLOB是Oracle数据库中一种用来存储大容量字符数据的数据类型,其全称为Character Large Object。
Oracle中Clob类型处理解析
Oracle中Clob类型处理解析2009-11-19 10:47:07作者:(414)繁體中文字号:T|T我要收藏或分享到:[导读]Oracle中Clob类型处理解析最近利用NHibernate映射类型为Clob字段在插入数据时发现当字符的字节数(一个半角字符一个字节,一个全角字符两个字节)在2000-4000之间时报错(ORA-01461:仅可以插入LONG列的LONG值赋值)。
Oracle中Clob类型处理解析最近利用NHibernate映射类型为Clob字段在插入数据时发现当字符的字节数(一个半角字符一个字节,一个全角字符两个字节)在2000-4000之间时报错(ORA-01461:仅可以插入LONG列的LONG值赋值)。
经过不断查找资料和自己的试验该问题终于得到解决,下边我将自己的心得给大家做一个分享。
准备系统环境xp+.net2.0+oracle9i表结构(由于是测试,表结构随便建了一张)XX字段名类型IDVARCHAR2(70)TESTCLOB测试方式1:直接将CLOB的值拼写在SQL语句中。
代码:string id = Guid.NewGuid().ToString();OracleCommand cmd = Conn.CreateCommand();mandText = "insert into xx(id,test) values('" + id + "','" + data + "')";// data是一个变量,存储你要插入的字符串cmd.ExecuteNonQuery();情况分析:当data的长度大于4000时报错(ORA-01704:文字字符串过长),小于或等于4000时正常插入。
原因分析:之所以会出现长度大于4000时报错,是因为Oracle中有SQL语句中两个单引号之间的字符数不能大于4000的限制。
oracle的大文本类型
oracle的大文本类型
Oracle数据库中支持大文本类型,即CLOB和NCLOB类型。
CLOB 类型用于存储长文本数据,最大长度为4GB,NCLOB则用于存储Unicode字符集的长文本数据,最大长度也为4GB。
CLOB类型的数据可以通过INSERT、UPDATE和SELECT语句进行操作。
需要注意的是,由于CLOB类型的数据比较大,所以需要使用LOB locator来访问和修改CLOB数据。
NCLOB类型与CLOB类型类似,只是它可以存储Unicode字符集的数据。
同样,NCLOB类型的数据也需要使用LOB locator来访问和修改。
在使用CLOB和NCLOB类型时,需要注意以下几点:
1. 在创建表时,需要指定该列的数据类型为CLOB或NCLOB。
2. 在插入数据时,需要使用“TO_LOB”函数将数据转换为LOB locator。
3. 在查询数据时,需要使用“DBMS_LOB.SUBSTR”函数来获取CLOB或NCLOB数据的子串。
4. 在更新数据时,需要使用“DBMS_LOB.WRITE”函数来修改CLOB 或NCLOB数据。
总之,大文本类型在Oracle数据库中是非常有用的数据类型,可以方便地存储和操作长文本数据。
但是,由于数据量较大,需要注意一些细节问题。
- 1 -。
spring+hibernate处理CLOB字段报错问题
关于处理CLOB字段,网上参考了下,主要补充下关于spring+hibernate处理需要事务管理: 今天在开发项目的时候遇到CLOB字段的问题,和平时的String字段一样处理发现HQL的查询结果是NULL,到网上查找了一些资料,处理方式作了一些修改以后,数据成功显示,现总结配置如下:applicationContext.xml配置修改如下:<beanid="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionF actoryBean"><property name="hibernateProperties"><props><prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop></props></property><property name="dataSource"><ref bean="dataSource" /></property><property name="configLocation"><value>classpath:hibernate.cfg.xml</value></property><property name="lobHandler"><ref bean="oracleLobHandler" /></property></bean><!-- 使用spring+hibernate处理oracle BLOB--><bean id="nativeJdbcExtractor" class="org.springframework.jdbc.support.nativejdbc.SimpleNativeJdbcExtractor" /><bean id="oracleLobHandler" class="org.springframework.jdbc.support.lob.OracleLobHandler"lazy-init="true"><property name="nativeJdbcExtractor"><ref bean="nativeJdbcExtractor" /></property></bean><!-- 完毕-->请注意:oracleLobHandler,nativeJdbcExtractor,oracleLobHandler3:这个时候我们操作起blob,clob就非常方便了:*.hbm.xml配置修改如下:a:操作blob,java类的成员变量类型设置为byte[],映射文件设置为:org.springframework.orm.hibernate3.support.BlobByteArrayTypeb:操作clob,java类的成员变量类型设置为String,映射文件设置为:org.springframework.orm.hibernate3.support.ClobStringType使用的时候不用额外考虑,可以直接象平常使用就可以了。
Hibernate操作Clob类型完整版!
Hibernate操作Clob类型完整版!最近,使用Hibernate操作Clob。
上网看了不少资料,感觉五花八门,实现起来的方法都各不相同。
有的是Hibernate2.0上的。
有的是加入了spring的支持,把clob当成string做处理(的确很好,但是不适合新手)........而且,某些代码根本都执行不了~浪费我们的时间,55555555。
于是,法老参考了一些官网的方法加以修改,干脆重新写一个完整元操作版本。
包含:insert,update,delete,select 四大基本方法!供大家参考!-------------------------------------------测试环境介绍:WINDWOS XP SP2;Eclipse 3.2;JDK 1.4.2Hibernate-Version: 3.0.5 ;oracle 9i ;=====================重点说明:1。
配置文件hbm.xml里把clob的type="clob"片段如下<property name="bsznContent" type="clob"><column name="BSZN_CONTENT"not-null="true" /></property>2。
实体bean中,导入java.sql.Clob包(注意不是oracle.sql.CLOB 个人习惯用血统纯点的.这里鄙视一下oracle。
嘿嘿)在该字段对应的实体文件里面,增加以下两个变量及其相应的get/set方法import java.sql.Clob;...private Clob bsznContent;private String bsznContentString;...public Clob getBsznContent() {return this.bsznContent;}public void setBsznContent(Clob bsznContent) { this.bsznContent = bsznContent;}public String getBsznContentString() {return bsznContentString;} public void setBsznContentString(String bsznContentString) {this.bsznContentString = bsznContentString;}bsznContent 属性是默认的clob,bsznContentString 属性是对bsznContent做转换时候用的----------------------------------------好了废话不多说,把代码写下来吧~建表SQL=================/* Table: "cmp_bszn" 相关SQL*//*=========================================== ===================*/create table "cmp_bszn" ("id" INTEGERnot null,"kind" CHAR(2)not null,"bszn_title1" VARCHAR2(200)not null,"bszn_title2" VARCHAR2(200),"bszn_code" VARCHAR2(50),"bszn_bumen" VARCHAR2(50),"bszn_date" VARCHAR2(50),"bszn_content" CLOBnot null,"sys_date" DATEdefault SYSDATE not null,constraint PK_CMP_BSZN primary key ("id"));hibernate.cfg.xml 由于调试用,用的是JDBC连接方法,要使用连接池,请自行修改.记得自己把数据库地址和用户名,秘密改下<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD3.0//EN""/hibernate-configuration-3.0.dtd"><!-- Generated by MyEclipse Hibernate Tools. --><hibernate-configuration><session-factory><propertyname="ername">sa</property><property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:web</property><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><propertyname="connection.password">saweb</property><property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property> <propertyname="show_sql">true</property><propertyname="eUnicode">true</property><propertyname="connection.characterEncoding">GBK</proper ty><!-- 設定事務管理的工廠類--><propertyname="hibernate.transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory </property><property name="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory </property><mapping resource="clob/cmpBszn.hbm.xml" /> </session-factory></hibernate-configuration>cmpBszn.hbm.xml<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dt d"><!--Mapping file autogenerated by MyEclipse - Hibernate Tools--><hibernate-mapping><class name="cmpBszn" table="CMP_BSZN"schema="SA"><id name="id" type="ng.Long"><column name="ID" precision="22" scale="0" /><generatorclass="increment"></generator></id><property name="kind"type="ng.String"><column name="KIND" length="2" not-null="true" /></property><property name="bsznTitle1"type="ng.String"><column name="BSZN_TITLE1" length="200" not-null="true" /></property><property name="bsznTitle2"type="ng.String"><column name="BSZN_TITLE2" length="200" /></property><property name="bsznCode"type="ng.String"><column name="BSZN_CODE"length="50" /></property><property name="bsznBumen"type="ng.String"><column name="BSZN_BUMEN"length="50" /></property><property name="bsznDate"type="ng.String"><column name="BSZN_DATE" length="50" /></property><property name="bsznContent" type="clob"><column name="BSZN_CONTENT"not-null="true" /></property><property name="sysDate"type="java.util.Date"><column name="SYS_DATE" length="7"not-null="true" /></property></class></hibernate-mapping>抽象类AbstractcmpBszn.java// default packageimport java.sql.Clob;import java.util.Date;/*** AbstractcmpBszn generated by MyEclipse - Hibernate Tools*/public abstract class AbstractcmpBszn implements java.io.Serializable { // Fields private Long id;private String kind;private String bsznTitle1;private String bsznTitle2;private String bsznCode;private String bsznBumen;private String bsznDate;private Clob bsznContent;private String bsznContentString;private Date sysDate; // Constructors /** default constructor */public AbstractcmpBszn() {} /** minimal constructor */public AbstractcmpBszn(String kind, String bsznTitle1, Clob bsznContent, Date sysDate) {this.kind = kind;this.bsznTitle1 = bsznTitle1;this.bsznContent = bsznContent;this.sysDate = sysDate;}/** full constructor */public AbstractcmpBszn(String kind, String bsznTitle1, String bsznTitle2, String bsznCode, String bsznBumen, String bsznDate, Clob bsznContent, Date sysDate) {this.kind = kind;this.bsznTitle1 = bsznTitle1;this.bsznTitle2 = bsznTitle2;this.bsznCode = bsznCode;this.bsznBumen = bsznBumen;this.bsznDate = bsznDate;this.bsznContent = bsznContent;this.sysDate = sysDate;}// Property accessors public Long getId() {return this.id;}public void setId(Long id) {this.id = id;} public String getKind() {return this.kind;}public void setKind(String kind) {this.kind = kind;} public String getBsznTitle1() {return this.bsznTitle1;}public void setBsznTitle1(String bsznTitle1) { this.bsznTitle1 = bsznTitle1;} public String getBsznTitle2() {return this.bsznTitle2;}public void setBsznTitle2(String bsznTitle2) {this.bsznTitle2 = bsznTitle2;} public String getBsznCode() {return this.bsznCode;}public void setBsznCode(String bsznCode) { this.bsznCode = bsznCode;} public String getBsznBumen() {return this.bsznBumen;}public void setBsznBumen(String bsznBumen) { this.bsznBumen = bsznBumen;} public String getBsznDate() {return this.bsznDate;}public void setBsznDate(String bsznDate) { this.bsznDate = bsznDate;} public Clob getBsznContent() {return this.bsznContent;}public void setBsznContent(Clob bsznContent) { this.bsznContent = bsznContent;} public Date getSysDate() {return this.sysDate;}public void setSysDate(Date sysDate) {this.sysDate = sysDate;} public String getBsznContentString() {return bsznContentString;} public void setBsznContentString(String bsznContentString) {this.bsznContentString = bsznContentString;}}实体类cmpBszn// default package// Generated by MyEclipse - Hibernate Toolsimport java.sql.Clob;import java.util.Date;/*** cmpBszn generated by MyEclipse - Hibernate Toolspublic class cmpBszn extends AbstractcmpBszn implements java.io.Serializable { // Constructors /** default constructor */public cmpBszn() {} /** minimal constructor */public cmpBszn(String kind, String bsznTitle1, Clob bsznContent, Date sysDate) {super(kind, bsznTitle1, bsznContent, sysDate);}/** full constructor */public cmpBszn(String kind, String bsznTitle1, String bsznTitle2, String bsznCode, String bsznBumen, String bsznDate, Clob bsznContent, Date sysDate) {super(kind, bsznTitle1, bsznTitle2, bsznCode, bsznBumen, bsznDate, bsznContent, sysDate);}}SessionManager管理类(这个是通用的,如果你要自己写也可以)package Hib_DB;importorg.hibernate.HibernateException;import org.hibernate.Session;import org.hibernate.cfg.Configuration;/*** Configures and provides access to Hibernate sessions, tied to the* current thread of execution. Follows the Thread Local Session* pattern, see {@link /42.html }.*/public class SessionManager { /*** Location of hibernate.cfg.xml file.* Location should be on the classpath as Hibernate uses* #resourceAsStream style lookup for its configuration file.* The default classpath location of the hibernate config file is* in the default package. Use #setConfigFile() to update* the location of the configuration file for the current session.*/private static String CONFIG_FILE_LOCATION ="/hibernate.cfg.xml";private static final ThreadLocal threadLocal = new ThreadLocal();private static Configuration configuration = new Configuration();private static org.hibernate.SessionFactory sessionFactory;private static String configFile =CONFIG_FILE_LOCATION; private SessionManager() {}/*** Returns the ThreadLocal Session instance. Lazy initialize* the <code>SessionFactory</code> if needed.** @return Session* @throws HibernateException*/public static Session getSession() throwsHibernateException {Session session = (Session) threadLocal.get(); if (session == null || !session.isOpen()) {if (sessionFactory == null) {rebuildSessionFactory();}session = (sessionFactory != null) ? sessionFactory.openSession(): null;threadLocal.set(session);} return session;} /*** Rebuild hibernate session factory**/public static void rebuildSessionFactory() {try {configuration.configure(configFile);sessionFactory =configuration.buildSessionFactory();} catch (Exception e) {System.err.println("%%%% Error Creating SessionFactory %%%%");e.printStackTrace();}} /*** Close the single hibernate session instance.** @throws HibernateException*/public static void closeSession() throws HibernateException {Session session = (Session) threadLocal.get();threadLocal.set(null); if (session != null) { session.close();}} /*** return session factory**/public static org.hibernate.SessionFactory getSessionFactory() {return sessionFactory;} /*** return session factory** session factory will be rebuilded in the next call */public static void setConfigFile(String configFile) { SessionManager.configFile = configFile;sessionFactory = null;} /*** return hibernate configuration**/public static Configuration getConfiguration() {return configuration;}}Test_Work实际测试类import java.sql.SQLException; import java.util.Date;import java.util.Iterator;import java.util.List;import org.hibernate.Hibernate; import org.hibernate.HibernateException;import org.hibernate.Query;import org.hibernate.Session;import org.hibernate.Transaction;importHib_DB.SessionManager;public class Test_Work { /** * @param args* @throws SQLException* @throws SQLException*/*=========================================== ===================*//* Table: "cmp_bszn" 相关SQL*//*=========================================== ===================*//*create table "cmp_bszn" ("id" INTEGERnot null,"kind" CHAR(2)not null,"bszn_title1" VARCHAR2(200)not null,"bszn_title2" VARCHAR2(200),"bszn_code" VARCHAR2(50),"bszn_bumen" VARCHAR2(50),"bszn_date" VARCHAR2(50),"bszn_content" CLOBnot null,"sys_date" DATEdefault SYSDATE not null,constraint PK_CMP_BSZN primary key ("id") );*/public static void main(String[] args) throws SQLException {Test_Work exam = new Test_Work();/*Insert*/exam.InsertRecords();exam.QueryRecords();/*Update*/exam.Demo_Update(new Long(5));/*Delete*/exam.DeleteRecords(new Long(3));} /** 查询*/private void QueryRecords() throws SQLException { try {Session session =SessionManager.getSession();Query records = session.createQuery("from cmpBszn order by id");List record = records.list();Iterator iterator = record.iterator();while (iterator.hasNext()) {cmpBszn obj = (cmpBszn)iterator.next();System.out.println(obj.getId() + " " + obj.getKind());java.sql.Clob clob =obj.getBsznContent();if (clob != null) {String b1 = clob.getSubString(1, (int) clob.length());obj.setBsznContentString(b1);}System.out.println(obj.getBsznContentString());System.out.println("----------------------------------");}System.out.println(record.size());} catch (HibernateException e) {System.out.println("error");} finally {try {// Step 5 - close the sessionSessionManager.closeSession();} catch (HibernateException e1) {// do nothing}}} private void QueryRecords(Long id) throws SQLException {try {Session session =SessionManager.getSession();Query records = session.createQuery("from cmpBszn orderby id where id = " + id);List record = records.list();Iterator iterator = record.iterator();while (iterator.hasNext()) {cmpBszn obj = (cmpBszn)iterator.next();java.sql.Clob clob =obj.getBsznContent();if (clob != null) {String b1 = clob.getSubString(1, (int) clob.length());obj.setBsznContentString(b1);}System.out.println(obj.getId() + " " + obj.getKind() + " "+ obj.getBsznTitle1());System.out.println("内容:" +obj.getBsznContentString());System.out.println("----------------------------------");}} catch (HibernateException e) {System.out.println("error");} finally {try {// Step 5 - close the sessionSessionManager.closeSession();} catch (HibernateException e1) {// do nothing}}} /** 插入*/private void InsertRecords() {String kind = "03";String bsznTitle1 = "ttttttttt";String bsznContentString = "哈哈成功了";Date sysDate = new Date();try {Session session =SessionManager.getSession();Transaction tx = session.beginTransaction();cmpBszn obj = new cmpBszn();obj.setKind(kind);obj.setBsznTitle1(bsznTitle1);obj.setSysDate(sysDate);obj.setBsznContent(Hibernate.createClob(bsznContentStri ng));// 关键createClob方法session.save(obj);mit();System.out.println("Save Success.");} catch (Exception e) {System.out.println("Save failed.");} finally {try {SessionManager.closeSession();} catch (HibernateException e1) {}}} private void UpdateRecords(Long id) {String kind = "03";String bsznTitle1 = "update_test";String bsznContentString = "修改更新";Date sysDate = new Date();try {Session session =SessionManager.getSession();Transaction tx = session.beginTransaction();cmpBszn obj = (cmpBszn)session.load(cmpBszn.class, id);obj.setKind(kind);obj.setBsznTitle1(bsznTitle1);obj.setSysDate(sysDate);obj.setBsznContent(Hibernate.createClob(bsznContentStri ng));// 关键session.update(obj);mit();System.out.println("Save Success.");} catch (Exception e) {System.out.println("Save failed.");} finally {try {SessionManager.closeSession();} catch (HibernateException e1) {}}} /** 删除记录*/private void DeleteRecords(Long id) {try {Session session =SessionManager.getSession();cmpBszn message = (cmpBszn)session.load(cmpBszn.class, id);Transaction tx = session.beginTransaction();session.delete(message);mit();System.out.println("Delete successful.");} catch (HibernateException e) {// TODO 自动生成catch 块e.printStackTrace();System.out.println("删除失败!");} finally {try {// Step 5 - close the sessionSessionManager.closeSession();} catch (HibernateException e1) {// do nothing}} } private void Demo_Update(Long id) throws SQLException {System.out.println("修改前:");this.QueryRecords(id);this.UpdateRecords(id);System.out.println("修改后:");this.QueryRecords(id);}}--------------------------------------------好了~基本的核心代码都在这里了~写完后才发现QueryRecords(Long id)这个方法写的比较呆~效率不高~大家可以自己改写~参考文章:关于Clob类型在Hibernate中的应用小结找不到原始地址了Mapping a Clob to a String/76.htmlUsing Clobs with Oracle and Hibernate 1.2。
完全解读JAVA完全控制Oracle中BLOB、CLOB
网络上很多关于JAVA 对Oracle 中BLOB 、CLOB 类型字段的操作说明,有的不够全面,有的不够准确,甚至有的简直就是胡说八道。
最近的项目正巧用到了这方面的知识,在这里做个总结。
环境:Database: Oracle 9iApp Server: BEA Weblogic 8.14表结构:CREATE TABLE TESTBLOB (ID Int, NAME Varchar2(20), BLOBATTR Blob)CREATE TABLE TESTBLOB (ID Int, NAME Varchar2(20), CLOBATTR Clob)JA VA 可以通过JDBC ,也可以通过JNDI 访问并操作数据库,这两种方式的具体操作存在着一些差异,由于通过App Server 的数据库连接池JNDI 获得的数据库连接提供的java.sql.Blob 和java.sql.Clob 实现类与JDBC 方式提供的不同,因此在入库操作的时候需要分别对待;出库操作没有这种差异,因此不用单独对待。
一、BLOB 操作1、入库(1) JDBC 方式// 通过JDBC 获得数据库连接Class.forName("oracle.jdbc.driver.OracleDriver");Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:testdb", "test", "test");con.setAutoCommit(false);Statement st = con.createStatement();// 插入一个空对象empty_blob() st.executeUpdate("insert into TESTBLOB (ID, NAME, BLOBATTR) values (1, "thename", empty_blob())");II锁定数据行进行更新,注意"for update ”语句ResultSet rs = st.executeQuery("select BLOBA TTR from TESTBLOB where ID=1 for update");if (rs.next()){〃得到java.sql.Blob对象后强制转换为oracle.sql.BLOBoracle.sql.BLOB blob = (oracle.sql.BLOB) rs.getBlob("BLOBATTR");OutputStream outStream = blob.getBinaryOutputStream();IIdata 是传入的byte 数组,定义:byte[] dataoutStream.write(data, 0, data.length);}outStream.flush();outStream.close();mit();con.close();(2)JNDI 方式II通过JNDI获得数据库连接Context context = new InitialContext();ds = (DataSource) context.lookup("ORA_JNDI");Connection con = ds.getConnection();con.setAutoCommit(false);Statement st = con.createStatement();// 插入一个空对象empty_blob()st.executeUpdate("insert into TESTBLOB (ID, NAME, BLOBATTR) values (1, "thename", empty_blob())");II锁定数据行进行更新,注意"for update ”语句ResultSet rs = st.executeQuery("select BLOBA TTR from TESTBLOB where ID=1 for update");if (rs.next()){〃得到java.sql.Blob 对象后强制转换为weblogic.jdbc.vendor.oracle.OracleThinBlob (不同的App Server 对应的可能会不同)weblogic.jdbc.vendor.oracle.OracleThinBlob blob = (weblogic.jdbc.vendor.oracle.OracleThinBlob) rs.getBlob("BLOBA TTR");OutputStream outStream = blob.getBinaryOutputStream();IIdata 是传入的byte 数组,定义:byte[] data outStream.write(data, 0, data.length);}outStream.flush();outStream.close();mit();co n . cl o s e();2 、出库//获得数据库连接Connection con = ConnectionFactory.getConnection(); con.setAutoCommit(false);Statement st = con.createStatement();//不需要"for update ”ResultSet rs = st.executeQuery("select BLOBATTR from TESTBLOB where ID=1");if (rs.next()){java.sql.Blob blob = rs.getBlob("BLOBATTR"); InputStream inStream =blob.getBinaryStream();IIdata 是读出并需要返回的数据,类型是byte[]data = new byte[input.available()];inStream.read(data); inStream.close();}inStream.close(); mit();con.close();二、CLOB 操作1、入库(1) JDBC 方式//通过JDBC获得数据库连接Class.forName("oracle.jdbc.driver.OracleDriver");Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:testdb", "test", "test");con.setAutoCommit(false);Statement st = con.createStatement();// 插入一个空对象empty_clob()st.executeUpdate("insert into TESTCLOB (ID, NAME, CLOBATTR) values (1, "thename", empty_clob())");II锁定数据行进行更新,注意"for update ”语句ResultSet rs = st.executeQuery("select CLOBA TTR from TESTCLOB where ID=1 for update");if (rs.next()){〃得到java.sql.Clob对象后强制转换为oracle.sql.CLOB oracle.sql.CLOB clob =(oracle.sql.CLOB) rs.getClob("CLOBA TTR"); Writer outStream =clob.getCharacterOutputStream();IIdata 是传入的字符串,定义:String datachar[] c = data.toCharArray();outStream.write(c, 0, c.length);}outStream.flush();outStream.close();mit();con.close();(2) JNDI 方式II通过JNDI获得数据库连接Context context = new InitialContext();ds = (DataSource) context.lookup("ORA_JNDI");Connection con = ds.getConnection();con.setAutoCommit(false);Statement st = con.createStatement();II插入一个空对象empty_clob()st.executeUpdate("insert into TESTCLOB (ID, NAME, CLOBATTR) values (1, "thename", empty_clob())");II锁定数据行进行更新,注意"for update ”语句ResultSet rs = st.executeQuery("select CLOBA TTR from TESTCLOB where ID=1 for update");if (rs.next()){〃得到java.sql.Clob 对象后强制转换为weblogic.jdbc.vendor.oracle.OracleThinClob (不同的App Server 对应的可能会不同)weblogic.jdbc.vendor.oracle.OracleThinClob clob = (weblogic.jdbc.vendor.oracle.OracleThinClob) rs.getClob("CLOBA TTR");Writer outStream = clob.getCharacterOutputStream();IIdata 是传入的字符串,定义:String datachar[] c = data.toCharArray();outStream.write(c, 0, c.length);}outStream.flush();outStream.close();mit();con.close();2 、出库//获得数据库连接Connection con = ConnectionFactory.getConnection();con.setAutoCommit(false);Statement st = con.createStatement();// 不需要“ for update”ResultSet rs = st.executeQuery("select CLOBATTR from TESTCLOB where ID=1");if (rs.next()){java.sql.Clob clob = rs.getClob("CLOBA TTR");Reader inStream = clob.getCharacterStream();char[] c = new char[(int) clob.length()];inStream.read(c);//data 是读出并需要返回的数据,类型是Stringdata = new String(c);inStream.close();}inStream.close();mit();con.close();需要注意的地方:1、java.sql.Blob 、oracle.sql.BLOB 、weblogic.jdbc.vendor.oracle.OracleThinBlob 几种类型的区别2、java.sql.Clob 、oracle.sql.CLOB 、weblogic.jdbc.vendor.oracle.OracleThinClob 几种类型的区别。
spring Hibernate处理Oracle大字段clob
spring+Hibernate处理Oracle大字段clob在spring中采用OracleLobHandler来处理oracle大字段(包括clob和blob),则在程序中不需要引用oracle的特殊类,从而能够保证支持我们的代码支持多数据库。
1、首先数据表中的clob类型对应java持久化类的String类型;而blob类型对应byte[]类型2、定义hibernate标签时,持久化类中对应clob类型的属性的hibernate type应为org.springframework.orm.hibernate.support.ClobStringTyp e;而对应blob类型的属性的hibernate type应为org.springframework.orm.hibernate.support.BlobByteArray Type。
3、以后访问这些对应clob和blob类型的属性时,按普通属性处理,不需要特别编码。
java代码:< bean id ="mySessionFactory2" class="org.springframework.orm.hibernate.LocalSessionFactor yBean" >< property name ="dataSource" >< ref bean ="myDataSource2" /></ property >< property name ="lobHandler" >< ref bean ="oracleLobHandle" /></ property ></ bean >< bean id ="nativeJdbcExtractor" class="org.springframework.jdbc.support.nativejdbc.SimpleNati veJdbcExtractor" /> < bean id ="oracleLobHandle" class="org.springframework.jdbc.support.lob.OracleLobHandler " Lazy-init ="true" >< property name ="nativeJdbcExtractor" >< ref local ="nativejdbcExtractor" /></ property ></ bean > Spring为处理数据库Lob字段,特别提供了LobHandler接口。
mysql和Oracle在对clob和blob字段的处理
(3)hibernate配置文件中对应类型:
clob > clob blob > binay
也可以直接使用数据库提供类型,例如:oracle.sql.Clob,oracle.sql.Blob。
2、jdbc操作clob (以oracle为例)
while ((count = fin.read(data)) != -1)
{
total += count;
out.write(data, 0, count);
}
4、hibernateth处理clob
MyFile file = new Myfile();
if(null!=clob)
{
Reader is = clob.getCharacterStream();
BufferedReader br = new BufferedReader(is);
String s = br.readLine();
while (s != null)
{
content += s + "<br>";
s = br.readLine();
}
}
3、jdbc操作blob
conn.setAutoCommit(false);
String sql = "insert into photo(name,photo) values("jack",empty_blob());
* @roseuid 3EDA089E02BC
*/
Hibernate读写Clob和Blob类型字段
数据库脚本:create table testcb(id varchar(32) primary key,name varchar(32),photo blob,description text);Hibernate.cfg.xml"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><property name="ername">rootproperty><property name="connection.url">jdbc:mysql://localhost:3306/schoolproject?characterEncoding=gb2312&useUnicode=true property><property name="dialect">org.hibernate.dialect.MySQLDialectproperty><property name="myeclipse.connection.profile">mysqlproperty><property name="connection.password">1234property><property name="connection.driver_class">com.mysql.jdbc.Driverproperty><property name="hibernate.dialect">org.hibernate.dialect.MySQLDialectproperty><property name="hibernate.show_sql">trueproperty><property name="current_session_context_class">threadproperty><mapping resource="Search/Clob_Blob/TestCB.hbm.xml" />session-factory>hibernate-configuration>POJO:package Search.Clob_Blob;import java.sql.Blob;import java.sql.Clob;public class TestCB ...{private String id; //标识idprivate String name; //学生姓名private Blob photo;private Clob description;public String getId() ...{return id;}public void setId(String id) ...{this.id = id;}public String getName() ...{return name;}public void setName(String name) ...{ = name;}public Blob getPhoto() ...{return photo;}public void setPhoto(Blob photo) ...{this.photo = photo;}public Clob getDescription() ...{return description;}public void setDescription(Clob description) ...{ this.description = description;}}TestCB.hbm.xml"/hibernate-mapping-3.0.dtd"><hibernate-mapping package="Search.fetch" ><class name="Search.Clob_Blob.TestCB" table="testcb" lazy="true"><id name="id" column="id" unsaved-value="null"><generator class="uuid.hex">generator>id><property name="name" column="name" type="string">property><property name="photo" column="photo" type="blob">property><property name="description" column="description" type="clob">property>class>hibernate-mapping>准备一个图片sample.jpg放在Clob_Blob包下写Blob和Clob测试代码:package Search.Clob_Blob;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.sql.Blob;import java.sql.Clob;import org.hibernate.Hibernate;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;public class Test ...{public static void main(String[] args) ...{String filePath=System.getProperty("user.dir")+File.separator+"src/Search/Clob_Blob"+File.separator+"hi bernate.cfg.xml";File file=new File(filePath);SessionFactory sessionFactory=new Configuration().configure(file).buildSessionFactory();Session session=sessionFactory.openSession();Transaction tx=session.beginTransaction();try ...{String imgPath=System.getProperty("user.dir")+File.separator+"src/Search/Clob_Blob"+File.separator+ "sample.jpg";FileInputStream fis=new FileInputStream(imgPath);Blob photo=Hibernate.createBlob(fis);Clob description=Hibernate.createClob("this is description");TestCB testcb=new TestCB();testcb.setName("tom1");testcb.setPhoto(photo);testcb.setDescription(description);session.save(testcb);mit();} catch (FileNotFoundException e) ...{e.printStackTrace();} catch (IOException e) ...{e.printStackTrace();}}}、运行后,客户端中可以看到已经成功保存:运行读取测试代码:package Search.Clob_Blob;import java.io.BufferedReader;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.Reader;import java.sql.Blob;import java.sql.Clob;import java.sql.SQLException;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;public class TestRead ...{public static void main(String[] args) ...{String filePath=System.getProperty("user.dir")+File.separator+"src/Search/Clob_Blob"+File.separator+"hi bernate.cfg.xml";File file=new File(filePath);SessionFactory sessionFactory=new Configuration().configure(file).buildSessionFactory();Session session=sessionFactory.openSession();Transaction tx=session.beginTransaction();//读取clob和blobString imgPath=System.getProperty("user.dir")+File.separator+"src/Search/Clob_Blob"+File.separator+"sa mpleread.jpg";TestCB testcb=(TestCB)session.get(TestCB.class, "1");Blob photo=testcb.getPhoto();Clob description=testcb.getDescription();try ...{StringBuffer buffer=new StringBuffer();Reader reader=(Reader)description.getCharacterStream();BufferedReader breader=new BufferedReader(reader);char[] b = new char[60000];//每次获取60K//将Clob解析成Stringint i = 0;while((i = breader.read(b)) != -1)...{buffer.append(b,0,i);}System.out.println(buffer.toString());//将Blob还原成文件FileOutputStream fos=new FileOutputStream(imgPath);InputStream fis1=(InputStream)photo.getBinaryStream();byte[] b1 = new byte[60];//每次获取60Kint i1 = 0;while((i1=fis1.read(b1))!=-1)...{fos.write(b1);}} catch (SQLException e) ...{e.printStackTrace();} catch (IOException e) ...{e.printStackTrace();}mit();}}结果:Hibernate: select testcb0_.id as id0_0_, testcb0_.name as name0_0_, testcb0_.photo as photo0_0_, testcb0_.description as descript4_0_0_ from testcb testcb0_ where testcb0_.id=?this is description红色部分为解析的Clob,同时在Clob_Blob下可以看到生成的sampleread.jpg。
Oracle中Clob类型处理解析
Oracle中Clob类型处理解析最近利用NHibernate映射类型为Clob字段在插入数据时发现当字符的字节数(一个半角字符一个字节,一个全角字符两个字节)在 2000-4000之间时报错(ORA-01461:仅可以插入LONG列的LONG值赋值)。
经过不断查找资料和自己的试验该问题终于得到解决,下边我将自己的心得给大家做一个分享。
准备系统环境 xp+.net2.0+oracle9i表结构(由于是测试,表结构随便建了一张) XX字段名类型IDVARCHAR2(70)TESTCLOB测试方式1:直接将CLOB的值拼写在SQL语句中。
代码:string id = Guid.NewGuid().ToString();OracleCommand cmd = Conn.CreateCommand();mandText = "insert into xx(id,test) values('" + id + "','" + data + "')";// data是一个变量,存储你要插入的字符串cmd.ExecuteNonQuery();情况分析:当data的长度大于4000时报错(ORA-01704:文字字符串过长),小于或等于4000时正常插入。
原因分析:之所以会出现长度大于4000时报错,是因为Oracle中有SQL语句中两个单引号之间的字符数不能大于4000的限制。
'" + data + "' data在sql语句之间,当data的值大于4000个字节时就会报错。
解决办法:这种方式比较棘手,但有更好的方式,下边会讲到。
方式2:采用参数形式。
代码:string id = Guid.NewGuid().ToString();OracleCommand cmd = Conn.CreateCommand();mandText = "insert into xx(id,test) values('" + id + "',:p1)";OracleParameter p1 = new OracleParameter("p1", OracleType.Clob);p1.Value = data; // data是一个变量,存储你要插入的字符串cmd.Parameters.Add(p1);cmd.ExecuteNonQuery();情况分析:采用这种方式能够正常插入。
java存取oracle中的COLB类型数据
一、如何去处理Clob、BLOB的大类型CLOB可用于存放大文本数据,最多可存储4GB数据,在应用开发中比较常见.java提供的sql.Clob类与之对应.它提供两个方法来读取Clob的数据:getCharacterStream() 方法返回按unicode编码的输入流(java.io.Reader对象) getAsciiStream() 方法返回按ASCII编码的输入流(java.io.InputStream对象) 所以如果你的数据库中有可能存储中文字符的话,就要使用前一个方法.现在举一个实际的例子,让我一步步学习如何使用CLOB.首先,创建一个含CLOB字段的表:create table test (id INTEGER, content clob);接下来, 我们通过JSP往这张表里插入一条记录,然后再获取显示它.插入操作:以上需要注意的几点是:1)clob类型的数据不能直接insert,要先通过empty_clob()方法给它分配一个locator(同理,blob的用empty_blob()函数分配locator).然后把它select出来(此时它当然没有数据,但结果集不是空的),得到一个Clob的对象,修改该对象的内容让它满足我们的需要,再通过update方法更新该行记录.2) 通过select修改含lob类型的记录时一定要锁定该行(通过for update关键字实现),否则oracle会报错.3) 刚插入的记录就select for update, 会出现"违反读取顺序"错误,解决办法是将自动提交功能置为false,即不允许自动提交,然后commit它,再select,就可以了. 这就是上面那段代码里//*两行的作用.下面,我们将刚插入的记录从数据库中读取出来并显示之:二、编码问题因为JAVA的开发者是老外,所以他们对中文的支持并不是太好,这一点让不少的我们感到很是头痛,也就是我们通过说的汉字编码问题吧,关于一些汉字编码的规范我就不多说了,我主要是谈谈在和oracle数据库连接时的一些小问题,不过这些小问题很是让人头痛的。
Hibernate集成spring读写oracle clob
Hibernate集成spring读写oracle clob完全版前言Hibernate操作oracle clob字段是个大难题,网上的很多范例不详。
Hibernate与spring集成后操作又有区别,学习者不知从何下手。
本文讲解了读写oracle clob大对象的实现,并且带有完整的可运行范例下载。
希望对学习者有所帮助。
本文的内容如下1.数据库的脚本2.spring与hibernate的集成配置3.实体类的配置4.DAO层和BO层的实现5.测试代码6.错误代码以及原因一、数据库脚本表建在scott模式下,密码tiger测试在过程中的content字段是否写入spring与hibernate的集成配置3个提示:1.批处理的设置必须为0<prop key="hibernate.jdbc.batch_size">0</prop>2.必须使用事务,保证BO层的操作在一个事务中3.如果你对spring的注入依赖有疑问,我也没有办法DemoTO.hbm.xml文件1.数据库的表只有2个字段,clob要映射为java.sql.Clob类型。
当然有些人映射为String类型,如果那样做当字符串长度到一定长度时会出现错误。
2.额外加字段contentStr的目的只是为了插入数据的方便。
三、DAO层和BO层的实现DemoDAO.java1.只取必须的dao方法,别的省略。
2.save()方法绝对不行,必须使用save1()3.只是个demo,我不抽接口了DemoBO.java四、测试代码1.我在clob字段插入的内容,超过1万个字符,毕竟是字符大对象2.另外的范例测试读取大字段只读前100个字符没有正确配置事务管理save1()的方法中,save1方法只有配置bo层的事务管理才能处于同一个会话中。
很多书上说以下的语法是对的,也许在以前的某个版本对。
oracle.sql.CLOB clob=(oracle.sql.CLOB) demo.getContent();我使用的是spring2.0和hibernate3.1,请注意我在save1()方法如何转换的。
hibernate的oracle配置(转)
hibernate的oracle配置(转)连接Oracle数据库的Hibernate配置⽂件连接Oracle的Hibernate配置⽂件有两种格式,⼀种是xml格式的,另⼀种是Java属性⽂件格式的。
下⾯分别给出这两种格式配置⽂件的代码。
1.xml格式的配置⽂件下⾯将给出连接本地Oracle服务器上的db_database02数据库时Hibernate配置⽂件hibernate.cfg.xml的代码。
例程2-5:光盘/mr/02/sl/05/hibernate.cfg.xml<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configurationPUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"""><hibernate-configuration><session-factory><!--指定连接数据库⽤的驱动--><property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property><!--指定连接数据库的路径--><property name="connection.url">jdbc:oracle:thin:@localhost:1521:db_database02</property><!--指定连接数据库的⽤户名--><property name="ername">SYSTEM</property><property name="connection.password">SYSTEM</property><!--指定连接数据库的密码--><!--指定数据库使⽤的SQL⽅⾔--><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><!--当show_sql属性为true时表⽰在程序运⾏时在控制台输出SQL语句,默认为false,建议在调试程序时设为true,发布程序之前再改为false,因为输出SQL语句会影响程序的运⾏速度--><property name="show_sql">true</property><mapping resource="UserForm.hbm.xml"/><!--指定持久化类映射⽂件--></session-factory></hibernate-configuration>在上⾯的代码中,“localhost”代表本地Oracle服务器,如果想连接其他服务器可以修改为要连接的Oracle服务器的名称;“db_database02”为要连接的数据库名称;“SYSTEM”为登录⽤户名;“SYSTEM”表⽰⽤户密码; “UserForm.hbm.xml”为持久化类对应的映射⽂件名称。
hibernate连接oracle数据库
一、Hibernate介绍Hibernate是基于对象/关系映射(ORM,Object/Relational Mapping)的一个解决方案。
ORM方案的思想是将对象模型表示的对象映射到关系型数据库中,或者反之。
Hibernate目前是ORM思想在Java中最成功、最强大的实现。
它于2001年的年末发布第一个版本,立即引起了广泛的注意。
2003年6月,Hibernate2发表,并且获得Jolt大奖,进而被JBoss吸纳成为它的一个子项目。
2005年3月,Hibernate3发表,其中做了一些比较重大的改进。
本文以Hibernate3为基础编写。
另外,Hibernate除了可以在J2EE容器中运行外,还可以运行在Java应用程序中。
本文就是以Java应用程序为例来介绍它。
二、配置开发环境本文以一个Java应用程序(Java Application)为例,介绍如何使用Hibernate来进行数据库操作。
在进行Hibernate开发之前,需要首先获得Hibernate类库、相应数据库的JDBC驱动类库。
Hibernate类库可以从中下载,目前的版本是3.0。
而JDBC驱动可以根据不同的数据库来选择,在这个例子中,使用的是Oracle数据库,那么相应的JDBC驱动可以从Oracle安装目录\ora92\jdbc下获得。
其他的数据库请根据相关的说明获得。
下载Hibernate包后,可以将它解压到一个文件夹,此处假设为C:\hibernate-3.0,然后将C:\hibernate-3.0\下的hibernate.jar和C:\hibernate-3.0\lib下的那些第三方类库也放到环境变量CLASSPATH中。
(通常,只需要dom4j、cglig、commons-logging、commons-collections、log4j、ehcache、asm、jta、antlr这些类库就可以了)做完这些配置后,就可以在此基础上进行基于Hibernate的Java程序开发了。
oracle中clob类型
oracle中clob类型
一、字段类型的区别在Oracle 数据库中,可以使用不同的字段类型来描述不同的对象。
在存储过程中,Oracle 中使用的字段类型是对象的实例化类型。
二、字符串和数组的区别在Oracle 数据库中,每个对象都有一个唯一的名称,也就是说每个对象都是唯一的。
当然,Oracle 中也支持使用字符串,但是这些字符串并非唯一的。
Oracle 数据库中的字符串包括整型(int)、浮点型(float)、布尔型(bool)和字符型(string)等四种。
三、列表字段的区别在Oracle 数据库中,存储过程中每个对象都是按照字段类型排序的。
所谓字段类型,就是指SQL 语句中的标识符。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1问题描述当我们需要操作大于4000字节的数据(字段)时,我们就需要用到oracle的CLOB数据类型。
在对其进行操作时主要有以下三种方案:采用传统的jbdc方式、把clob以string方式处理和直接使用CLOB类型三种方案,下面分别作简要介绍。
2对CLOB数据类型的操作2.1 方式一传统的jdbc方式写入Blob/Clob字段和写入其它类型字段的方式非常不同,因为Blob/Clob自身有一个cursor,必须使用cursor对Blob/Club进行操作,因而在写入Blob/Club之前,必须获得cursor才能进行写入,那就需要先插入一个empty的Blob/Club,这将创建一个Blob/Club的cursor,然后再把这个empty的Blob/Club的cursor用select查询出来,这样通过两步操作,就获得了Blob/Club的cursor,可以真正的写入Blob/Club数据了。
这种方式比较麻烦,读写都要增加不少工作量。
有关此方法的具体实现代码请参照示例一。
2.2 方式二把CLOB以String方式处理此方法主要是通过继承net.sf.hibernate.type.ImmutableType类或erType类来创建一个新的类如:StringClobType,然后在相应的配置文件里面,把该字段映射为StringClobType类型,即可正常操作。
此方法的优点主要体现在具体实现操作的代码较为简单,但在第一步的映射问题上,较难理解。
有关此方法的具体实现代码请参照示例二。
2.3 方式三直接使用CLOB类型第三种方法是直接使用clob类型,它主要是在实体中增加一个clobString字段,通过对该字段的读写,在DAOImpl层进行特殊处理后,转换为真正的clob类型,从而实现clob类型字段的CRUD操作。
此方法主要优点体现在配置文件的映射类型上,只需要像映射其它基本类型一样,直接写上type="clob" 就OK了。
这对初次遇到这种问题的人来说入门相对容易。
2.3.1使用方法下面以文章(只考虑文章标题和文章内容)为例介绍其使用方法。
2.3.2基本配置1.实体类配置在正常情况下文章实体类如下所示:package testCLOB;public class Article {private String title;private String content;public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getContent() {return content;}public void setContent(String content) {this.content = content;}}但是由于需要使用CLOB数据类型,该实体类需要进行如下变化:package com.maskhr.jhb;import java.sql.Clob;public class Article {private String title;private Clob content;private String contentString;public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public Clob getContent() {return content;}public void setContent(Clob content) {this.content = content;}public String getContentString() {return contentString;}public void setContentString(String contentString) {this.contentString = contentString;}}其中contentString并不映射到数据库的CLOB字段,只是方便用户使用get / set 处理CLOB字段2.hibernate映射文件在该实体对应的映射文件里只需要增加下面一行,直接声明该字段为clob类型。
< property name="content " column="CONTENT_CLOB" type="clob" />3.创建的实现Session sess = HibernateHelper.currentTransaction();Serializable result = sess.save(mh);sess.flush();//初始化SummaryClob字段oracle.sql.CLOB clob = oracle.sql.CLOB.empty_lob();mh.setSummaryClob(clob);/*也可采用此方法进行初始化mh.setSummaryClob (Hibernate.createClob(""));*///此处一定要用lockMode.UPGRADE模式进行锁定刷新sess.refresh(mh, LockMode.UPGRADE);//获取MeetingHead实体的SummaryClobString属性值String content = mh.getSummaryClobString();//将获取的辅助字段的值通过oracle.sql.CLOB的putString()方法赋值给实体内的summaryClob字段oracle.sql.CLOB clob = (oracle.sql.CLOB) mh.getSummaryClob();clob.putString(1, content);HbernateHelper.endCurrentTransaction();return result;4.更新的实现Session sess = HibernateHelper.currentTransaction();// 首先通过锁模式把该实体读出来MeetingHead oldMh = (MeetingHead) sess.load(clazz, mh.getId(), LockMode.UPGRADE);// 获取辅助字段的值String newMhValue = mh.getSummaryClobString();// 更新前首先要清空原clob字段的内容oracle.sql.CLOB clob_empty = oracle.sql.CLOB.empty_lob();oldMh.setSummaryClob(clob_empty);// 必须要执行以下两步,否则将抛出“不能对空clob进行读写操作”的异常sess.flush();sess.refresh(oldMh, LockMode.UPGRADE);//将获取的辅助字段的值通过oracle.sql.CLOB的putString()方法赋值给实体内的summaryClob字段oracle.sql.CLOB clob = (oracle.sql.CLOB)oldMh.getSummaryClob();clob.putString(1, newMhValue);5.读取的实现MeetingHead mh = (MeetingHead) service.getMeetingHeadById(id);// 获取实体的Clob字段的值java.sql.Clob clob = mh.getSummaryClob();// 将获取的Clob值通过java.sql.Clob的getSubString()方法赋值给实体的辅助字段if (clob != null) {String b1 = clob.getSubString(1, (int) clob.length());mh.setSummaryClobString(b1);}return mh;6.关于查询如何对CLOB字段进行全文检索?习惯了使用%来进行模糊查询,可发现在CLOB上行不通了,原来CLOB的查询是有专门的LOB操作工具的。
说明:CLOB字段可以select,但select时不可以使用whereSQL> create table a(a clob);SQL> insert into a values('1234');SQL> insert into a values('5648');SQL> select *from a;12345648SQL> select * from a where a like '%12%';select * from a where a like '%12%'ERROR 位于第1 行:ORA-00932: 数据类型不一致SQL> SELECT * FROM A WHERE dbms_lob.instr(a.a,'12',1,1)>0;1234SQL> SELECT * FROM A WHERE dbms_lob.instr(a.a,'5',1,1)>0;5648。