foobartest.java

介绍了hibernate的入门有一些基本常用的事例

//$Id: FooBarTest.java,v 1.28 2005/03/16 02:45:46 steveebersole Exp $
package org.hibernate.test.legacy;

import java.io.Serializable;
import java.sql.Connection;
import java.sql.Time;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.SortedSet;
import java.util.TimeZone;
import java.util.TreeMap;
import java.util.TreeSet;

import junit.framework.Test;
import junit.framework.TestSuite;
import junit.textui.TestRunner;

import org.hibernate.Criteria;
import org.hibernate.FetchMode;
import org.hibernate.FlushMode;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.LazyInitializationException;
import org.hibernate.LockMode;
import org.hibernate.ObjectDeletedException;
import org.hibernate.ObjectNotFoundException;
import org.hibernate.Query;
import org.hibernate.QueryException;
import org.hibernate.ScrollableResults;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
import org.hibernate.classic.Session;
import org.hibernate.connection.ConnectionProvider;
import org.hibernate.connection.DriverManagerConnectionProvider;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.Expression;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.dialect.DB2Dialect;
import org.hibernate.dialect.DerbyDialect;
import org.hibernate.dialect.HSQLDialect;
import org.hibernate.dialect.InterbaseDialect;
import org.hibernate.dialect.MckoiDialect;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.dialect.Oracle9Dialect;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.dialect.PointbaseDialect;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.dialect.SAPDBDialect;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.dialect.SybaseDialect;
import org.hibernate.dialect.TimesTenDialect;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.jmx.HibernateService;
import org.hibernate.mapping.RootClass;
import org.hibernate.proxy.HibernateProxy;
import org.hibernate.test.TestCase;
import org.hibernate.type.Type;
import org.hibernate.util.JoinedIterator;
import org.hibernate.util.SerializationHelper;

public class FooBarTest extends TestCase {

	public FooBarTest(String arg) {
		super(arg);
	}

	public void testSaveOrUpdateCopyAny() throws Exception {
		Session s = openSession();
		Bar bar = new Bar();
		One one = new One();
		bar.setObject(one);
		s.save(bar);
		GlarchProxy g = bar.getComponent().getGlarch();
		bar.getComponent().setGlarch(null);
		s.delete(g);
		s.flush();
		assertTrue( s.contains(one) );
		s.connection().commit();
		s.close();

		s = openSession();
		Bar bar2 = (Bar) s.saveOrUpdateCopy(bar);
		s.flush();
		s.delete(bar2);
		s.flush();
		s.connection().commit();
		s.close();
	}

	public void testRefreshProxy() throws Exception {
		Session s = openSession();
		Glarch g = new Glarch();
		Serializable gid = s.save(g);
		s.flush();
		s.clear();
		GlarchProxy gp = (GlarchProxy) s.load(Glarch.class, gid);
		gp.getName(); //force init
		s.refresh(gp);
		s.delete(gp);
		s.flush();
		s.connection().commit();
		s.close();
	}

	public void testOnCascadeDelete() throws Exception {

		if (getDialect() instanceof MySQLDialect) return;

		Session s = openSession();
		Baz baz = new Baz();
		baz.subs = new ArrayList();
		Baz sub = new Baz();
		sub.superBaz = baz;
		baz.subs.add(sub);
		s.save(baz);
		s.flush();
		assertTrue( s.createQuery("from Baz").list().size()==2 );
		s.connection().commit();
		s.delete(baz);
		s.flush();
		s.connection().commit();
		assertTrue( s.createQuery("from Baz").list().size()==0 );
		s.connection().commit();
		s.close();
	}

	public void testRemoveFromIdbag() throws Exception {
		Session s = openSession();
		Baz baz = new Baz();
		baz.setByteBag( new ArrayList() );
		byte[] bytes = { 12, 13 };
		baz.getByteBag().add( new byte[] { 10, 45 } );
		baz.getByteBag().add(bytes);
		baz.getByteBag().add( new byte[] { 1, 11 } );
		baz.getByteBag().add( new byte[] { 12 } );
		s.save(baz);
		s.flush();
		baz.getByteBag().remove(bytes);
		s.flush();
		baz.getByteBag().add(bytes);
		s.flush();
		s.delete(baz);
		s.flush();
		s.connection().commit();
		s.close();
	}

	public void testLoad() throws Exception {
		Session s = openSession();
		Qux q = new Qux();
		s.save(q);
		BarProxy b = new Bar();
		s.save(b);
		s.flush();
		s.connection().commit();
		s.close();
		s = openSession();
		q = (Qux) s.load(Qux.class, q.getKey() );
		b = (BarProxy) s.load( Foo.class, b.getKey() );
		b.getKey();
		assertFalse( Hibernate.isInitialized(b) );
		b.getBarString();
		assertTrue( Hibernate.isInitialized(b) );
		BarProxy b2 = (BarProxy) s.load( Bar.class, new String( b.getKey() ) );
		Qux q2 = (Qux) s.load( Qux.class, q.getKey() );
		assertTrue( "loaded same object", q==q2 );
		assertTrue( "loaded same object", b==b2 );
		assertTrue( Math.round( b.getFormula() ) == b.getInt()/2 );
		s.delete(q2);
		s.delete(b2);
		s.flush();
		s.connection().commit();
		s.close();
	}

	public void testJoin() throws Exception {
		Session s = openSession();
		Foo foo = new Foo();
		foo.setJoinedProp("foo");
		s.save(foo);
		s.flush();
		foo.setJoinedProp("bar");
		s.flush();
		String fid = foo.getKey();
		s.delete(foo);
		s.flush();
		s.connection().commit();
		s.close();

		s = openSession();
		Foo foo2 = new Foo();
		foo2.setJoinedProp("foo");
		s.save(foo2);
		s.find("select foo.id from Foo foo where foo.joinedProp = 'foo'");
		assertNull( s.get(Foo.class, fid) );
		s.delete(foo2);
		s.flush();
		s.connection().commit();
		s.close();

	}

	public void testDereferenceLazyCollection() throws Exception {
		Session s = openSession();
		Baz baz = new Baz();
		baz.setFooSet( new HashSet() );
		Foo foo = new Foo();
		baz.getFooSet().add(foo);
		s.save(foo);
		s.save(baz);
		foo.setBytes( "foobar".getBytes() );
		s.flush();
		s.connection().commit();
		s.close();

		s = openSession();
		foo = (Foo) s.get( Foo.class, foo.getKey() );
		assertTrue( Hibernate.isInitialized( foo.getBytes() ) );
		assertTrue( foo.getBytes().length==6 );
		baz = (Baz) s.get( Baz.class, baz.getCode() );
		assertTrue( baz.getFooSet().size()==1 );
		s.flush();
		s.connection().commit();
		s.close();

		getSessions().evictCollection("org.hibernate.test.legacy.Baz.fooSet");

		s = openSession();
		baz = (Baz) s.get( Baz.class, baz.getCode() );
		assertFalse( Hibernate.isInitialized( baz.getFooSet() ) );
		baz.setFooSet(null);
		s.flush();
		s.connection().commit();
		s.close();

		s = openSession();
		foo = (Foo) s.get( Foo.class, foo.getKey() );
		assertTrue( foo.getBytes().length==6 );
		baz = (Baz) s.get( Baz.class, baz.getCode() );
		assertFalse( Hibernate.isInitialized( baz.getFooSet() ) );
		assertTrue( baz.getFooSet().size()==0 );
		s.delete(baz);
		s.delete(foo);
		s.flush();
		s.connection().commit();
		s.close();
	}

	public void testMoveLazyCollection() throws Exception {
		Session s = openSession();
		Baz baz = new Baz();
		Baz baz2 = new Baz();
		baz.setFooSet( new HashSet() );
		Foo foo = new Foo();
		baz.getFooSet().add(foo);
		s.save(foo);
		s.save(baz);
		s.save(baz2);
		foo.setBytes( "foobar".getBytes() );
		s.flush();
		s.connection().commit();
		s.close();

		s = openSession();
		foo = (Foo) s.get( Foo.class, foo.getKey() );
		assertTrue( Hibernate.isInitialized( foo.getBytes() ) );
		assertTrue( foo.getBytes().length==6 );
		baz = (Baz) s.get( Baz.class, baz.getCode() );
		assertTrue( baz.getFooSet().size()==1 );
		s.flush();
		s.connection().commit();
		s.close();

		getSessions().evictCollection("org.hibernate.test.legacy.Baz.fooSet");

		s = openSession();
		baz = (Baz) s.get( Baz.class, baz.getCode() );
		assertFalse( Hibernate.isInitialized( baz.getFooSet() ) );
		baz2 = (Baz) s.get( Baz.class, baz2.getCode() );
		baz2.setFooSet( baz.getFooSet() );
		baz.setFooSet(null);
		assertFalse( Hibernate.isInitialized( baz2.getFooSet() ) );
		s.flush();
		s.connection().commit();
		s.close();

		s = openSession();
		foo = (Foo) s.get( Foo.class, foo.getKey() );
		assertTrue( foo.getBytes().length==6 );
		baz = (Baz) s.get( Baz.class, baz.getCode() );
		baz2 = (Baz) s.get( Baz.class, baz2.getCode() );
		assertFalse( Hibernate.isInitialized( baz.getFooSet() ) );
		assertTrue( baz.getFooSet().size()==0 );
		assertTrue( Hibernate.isInitialized( baz2.getFooSet() ) ); //fooSet has batching enabled
		assertTrue( baz2.getFooSet().size()==1 );
		s.delete(baz);
		s.delete(baz2);
		s.delete(foo);
		s.flush();
		s.connection().commit();
		s.close();
	}

	public void testCriteriaCollection() throws Exception {
		Session s = openSession();
		Baz bb = (Baz) s.createCriteria(Baz.class).uniqueResult();
		assertTrue(bb==null);
		Baz baz = new Baz();
		s.save(baz);
		s.flush();
		s.connection().commit();
		s.close();
		s = openSession();
		Baz b = (Baz) s.createCriteria(Baz.class).uniqueResult();
		assertTrue( Hibernate.isInitialized( b.getTopGlarchez() ) );
		assertTrue( b.getTopGlarchez().size()==0 );
		s.delete(b);
		s.flush();
		s.connection().commit();
		s.close();
	}

	public void testQuery() throws Exception {
		Session s = openSession();
		Foo foo = new Foo();
		s.save(foo);
		Foo foo2 = new Foo();
		s.save(foo2);
		foo.setFoo(foo2);

		List list = s.find("from Foo foo inner join fetch foo.foo");
		Foo foof = (Foo) list.get(0);
		assertTrue( Hibernate.isInitialized( foof.getFoo() ) );

		list = s.find("from Baz baz left outer join fetch baz.fooToGlarch");

		list = s.find(
			"select foo, bar from Foo foo left outer join foo.foo bar where foo = ?",
			foo,
			Hibernate.entity(Foo.class)
		);
		Object[] row1 = (Object[]) list.get(0);
		assertTrue( row1[0]==foo && row1[1]==foo2 );

		s.find("select foo.foo.foo.string from Foo foo where foo.foo = 'bar'");
		s.find("select foo.foo.foo.foo.string from Foo foo where foo.foo = 'bar'");
		s.find("select foo from Foo foo where foo.foo.foo = 'bar'");
		s.find("select foo.foo.foo.foo.string from Foo foo where foo.foo.foo = 'bar'");
		s.find("select foo.foo.foo.string from Foo foo where foo.foo.foo.foo.string = 'bar'");
		if ( ! (getDialect() instanceof HSQLDialect) ) s.find("select foo.string from Foo foo where foo.foo.foo.foo = foo.foo.foo");
		s.find("select foo.string from Foo foo where foo.foo.foo = 'bar' and foo.foo.foo.foo = 'baz'");
		s.find("select foo.string from Foo foo where foo.foo.foo.foo.string = 'a' and foo.foo.string = 'b'");

		s.find("from Bar bar, foo in elements(bar.baz.fooArray)");

		//s.find("from Baz as baz where baz.topComponents[baz].name = 'bazzz'");

		if ( (getDialect() instanceof DB2Dialect) && !(getDialect() instanceof DerbyDialect) ) {
			s.find("from Foo foo where lower( foo.foo.string ) = 'foo'");
			s.find("from Foo foo where lower( (foo.foo.string || 'foo') || 'bar' ) = 'foo'");
			s.find("from Foo foo where repeat( (foo.foo.string || 'foo') || 'bar', 2 ) = 'foo'");
			s.find("from Bar foo where foo.foo.integer is not null and repeat( (foo.foo.string || 'foo') || 'bar', (5+5)/2 ) = 'foo'");
			s.find("from Bar foo where foo.foo.integer is not null or repeat( (foo.foo.string || 'foo') || 'bar', (5+5)/2 ) = 'foo'");
		}
		if (getDialect() instanceof SybaseDialect) {
			s.iterate("select baz from Baz as baz join baz.fooArray foo group by baz order by sum(foo.float)");
		}

		s.find("from Foo as foo where foo.component.glarch.name is not null");
		s.find("from Foo as foo left outer join foo.component.glarch as glarch where glarch.name = 'foo'");

		list = s.find("from Foo");
		assertTrue( list.size()==2 && list.get(0) instanceof FooProxy );
		list = s.find("from Foo foo left outer join foo.foo");
		assertTrue( list.size()==2 && ( (Object[]) list.get(0) )[0] instanceof FooProxy );

		s.createQuery("from Bar, Bar").list();
		s.createQuery("from Foo, Bar").list();
		s.find("from Baz baz left join baz.fooToGlarch, Bar bar join bar.foo");
		s.find("from Baz baz left join baz.fooToGlarch join baz.fooSet");
		s.find("from Baz baz left join baz.fooToGlarch join fetch baz.fooSet foo left join fetch foo.foo");

		list = s.find("from Foo foo where foo.string='osama bin laden' and foo.boolean = true order by foo.string asc, foo.component.count desc");
		assertTrue( "empty query", list.size()==0 );
		Iterator iter = s.iterate("from Foo foo where foo.string='osama bin laden' order by foo.string asc, foo.component.count desc");
		assertTrue( "empty iterator", !iter.hasNext() );

		list = s.find("select foo.foo from Foo foo");
		assertTrue( "query", list.size()==1 );
		assertTrue( "returned object", list.get(0)==foo.getFoo() );
		foo.getFoo().setFoo(foo);
		foo.setString("fizard");
		//The following test is disabled for databases with no subselects...also for Interbase (not sure why).
		if ( 
				!(getDialect() instanceof MySQLDialect) && 
				!(getDialect() instanceof HSQLDialect) && 
				!(getDialect() instanceof MckoiDialect) && 
				!(getDialect() instanceof SAPDBDialect) && 
				!(getDialect() instanceof PointbaseDialect) &&
				!(getDialect() instanceof DerbyDialect)
		)  {
			// && !db.equals("weblogic") {