/*
Copyright (c) 2009 The Regents of the University of California.
All rights reserved.
Permission is hereby granted, without written agreement and without
license or royalty fees, to use, copy, modify, and distribute this
software and its documentation for any purpose, provided that the above
copyright notice and the following two paragraphs appear in all copies
of this software.
IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
ENHANCEMENTS, OR MODIFICATIONS.
*/
package org.clothocad.hibernate;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import javax.swing.filechooser.FileFilter;
import org.clothocore.api.data.ObjBase.ObjBaseDatum;
import org.clothocad.hibernate.data.*;
import org.clothocore.api.plugin.ClothoConnection;
import org.clothocore.api.data.*;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Conjunction;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.Restrictions;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
/**
*
* @author Bing Xia
*/
public class HibernateConnection implements ClothoConnection {
public HibernateConnection() {
}
@Override
public boolean connect() {
return false;
}
@Override
public boolean isAClothoDatabase() {
return true;
}
public static List<FileObject> getDefaultMappings() {
FileObject mappingDir = FileUtil.getConfigFile( "data/private/org.clothocad.hibernate" );
return Arrays.asList( mappingDir.getChildren() );
}
public boolean connect( URL hibernateXML, List<URL> mappings ) {
// Create a new configuration and configures it.
Configuration config = new Configuration();
for ( URL map : mappings ) {
config.addURL( map );
}
try {
// Attempt to create a session factory from the configuration.
// As long as this session factory is active, the connection is
// defined as active.
config.configure( hibernateXML );
fac = config.buildSessionFactory();
HibernateConnection.connection = this;
return true;
} catch ( Throwable e ) {
System.err.println( e );
e.printStackTrace();
fac = null;
return false;
}
}
@Override
public boolean disconnect() {
try {
fac.close();
return true;
} catch ( Throwable e ) {
e.printStackTrace();
System.err.println( e );
return false;
} finally {
fac = null;
}
}
@Override
public boolean isConnected() {
return fac != null;
}
@Override
public boolean save( ObjBase obj ) {
SearchtagTable.updateSearchTags( obj ); //JCA: Relays to save search tags for object
if ( obj.getType() == ObjType.PART ) {
//TODO: figure out a better way...if there is one
return savePart( (Part) obj );
}
Session session = null;
Transaction transaction = null;
try {
session = fac.openSession();
Object toSave = getHibernateDatum( obj, session ); //This will instantiate the objbaseTable constructor
if ( toSave == null ) {
return false;
}
//Do the save from the hibernateDatum constructor
transaction = session.beginTransaction();
hibernateDatum d = (hibernateDatum) toSave;
System.out.println( "hibernateconnectionplugin will save" + d.toString() + " " + d.getName() + " " + d.getUUID() ); // FIXME: remove in final version
session.saveOrUpdate( toSave );
transaction.commit();
//Do any secondary processing saves for new objBase's xrefs
if(d.needsSecondaryProcessing()) {
transaction = session.beginTransaction();
d.runSecondaryProcessing(obj);
session.saveOrUpdate( toSave );
transaction.commit();
}
session.close();
activeSession = null;
return true;
} catch ( RuntimeException e ) {
e.printStackTrace();
System.err.println( "Commit failed!" );
if ( transaction != null && transaction.isActive() ) {
try {
transaction.rollback();
} catch ( HibernateException e1 ) {
System.err.println( "Rollback failed" );
}
}
}
return false;
}
/**
* For saving a Part, since the order of operations for this save
* doesn't fit well into the normal save method.
* @param pt
* @return
*/
boolean savePart( Part pt ) {
Session s = null;
Transaction t = null;
try {
List<String> newXrefs = pt.getComposition();
s = fac.openSession();
if ( pt.getPartType() == Part.partType.Composite ) {
PartTable existingPart = (PartTable) getHibernateDatum( ObjType.PART, pt.getUUID(), s );
if ( existingPart != null ) {
// Part already exists
// Check if all the xrefs match perfectly
boolean changed = false;
Set<CompositeXref> curXrefs = existingPart.getCompositeXrefsForChildPart();
System.out.println( curXrefs.size() + " " + newXrefs.size() );
if ( curXrefs.size() == newXrefs.size() ) {
String[] curXrefUUIDs = new String[ curXrefs.size() ];
for ( CompositeXref xr : curXrefs ) {
String parentUUID = xr.getPartTableByParentPart().getUUID();
curXrefUUIDs[xr.getPosition()] = parentUUID;
}
for ( int i = 0; i < curXrefUUIDs.length; i++ ) {
if ( !newXrefs.get( i ).equals( curXrefUUIDs[i] ) ) {
changed = true;
}
}
} else {
changed = true;
}
if ( changed ) {
System.out.println( "changed" );
for ( CompositeXref xr : curXrefs ) {
System.out.println( "deleting " + xr );
t = s.beginTransaction();
s.delete( xr );
t.commit();
}
for ( int i = 0; i < newXrefs.size(); i++ ) {
String uuid = newXrefs.get( i );
CompositeXref cxr = new CompositeXref( UUID.randomUUID().toString(), new PartTable( uuid ), existingPart, i );
t = s.beginTransaction();
s.save( cxr );
t.commit();
}
}
} else {
// Part doesn't exist yet...have to save it, then save the xrefs
t = s.beginTransaction();
PartTable toSave = new PartTable( pt );
s.save( toSave );
t.commit();
// Save the xrefs
for ( int i = 0; i < newXrefs.size(); i++ ) {
CompositeXref xr = new CompositeXref( UUID.randomUUID().toString(), new PartTable( newXrefs.get( i ) ), toSave, i );
t = s.beginTransaction();
s.save( xr );
t.commit();
}
}
} else {
// Not a composite, can save much more simply
PartTable toSave = new PartTable( pt );
t = s.beginTransaction();
s.saveOrUpdate( toSave );
t.commit();
}
s.close();
return true;
} catch ( RuntimeException e ) {
e.printStackTrace();
System.err.println( "Commit failed!" );
if ( t != null && t.isActive() ) {
try {
t.rollback();
} catch ( HibernateException e1 ) {
System.err.println( "Rollback failed" );
}
}
}
return false;
}
public boolean saveDatum( Object toSave ) {
Session s = null;
Transaction t = null;
try {
s = fac.openSession();
t = s.beginTransaction();
if ( toSave != null ) {
s.saveOrUpdate( toSave );
} else {
return false;
}
t.commit();
s.close();
return true;
} catch ( RuntimeException e ) {
e.printStackTrace();
System.err.println( "Commit failed!" );
if ( t != null && t.isActive() ) {
try {
t.rollback();
} catch ( HibernateException e1 ) {
System.err.println( "Rollback failed" );
}
}
}
return false;
}
public boolean deleteDatum( Object toDelete ) {
Session s = null;
Transaction t = null;
try {
boolean startedsession = false;;
if(activeSession!=null) {
s = activeSession;
} else {
s = fac.openSession();
startedsession = true;
}
t = s.beginTransaction();
if ( toDelete != null ) {
s.delete( toDelete );
} else {
return false;
}
t.commit();
if(startedsession) {
s.close();
}
return true;
} catch ( RuntimeException e ) {
e.printStackTrace();
System.err.println( "Commit failed!" );
if ( t != null && t.isActive() ) {
try {
t.rollback();
} catch ( HibernateException e1 ) {
System.err.println( "Rollback failed" );
}
}
}
return false;
}
@Override
public int save( Collection<ObjBase> objs ) {
Session session = null;
Transaction transaction = null;
int succeeded = 0;
try {
session = fac.openSession();
for ( ObjBase obj : objs ) {
hibernateDatum toSave = getHibernateDatum( obj, session );
if ( toSave != null ) {
transaction = session.beginTransaction();
System.out.println( "hibernateconnectionplugin will save" + toSave.toString() + " " + toSave.getName() + " " + toSave.getUUID() );
session.saveOrUpdate( toSave );
succeeded++;
transaction.commit();
}
}
session.close();
} catch ( RuntimeException e ) {
e.printStackTrace();
System.err.println( "Commit failed!" );
if ( transaction != null && transaction.isActive() ) {
try {
transaction.rollback();
return 0;
} catch ( HibernateException e1 ) {
session.close();
System.err.println( "Rollback failed" );
}
}
}
return succeeded;
}
@Override
public ObjBaseDatum getDatum(ObjType type, String uuid) {
Session s = fac.openSession();
hibernateDatum data = getHibernateDatum( type, uuid, s );
ObjBaseDatum out = null;
if ( data != null ) {
out = data.getObjBaseDatum();
} else {
out = null;
}
s.close();
return out;
}
@Override
public boolean delete( ObjBase obj ) {
System.out.println( "Delete got called" );
if ( obj == null ) {
System.out.println( "Delete but ObjBase is null" );
return false;
}
//Query for any CollectionXref links and delete them
String query = "from Collectionxref where objectId='" + obj.getType() + "'";
Iterator xrefs = query( query );
while ( xrefs.hasNext() ) {
Object xr = xrefs.next();
Collectionxref csr = (Collectionxref) xr;
System.out.println( "Delete found an xref, and its deleting it" );
HibernateConnection.connection.deleteDatum( csr );
}
Session s = null;
Transaction t = null;
try {
System.out.println( "Delete doing a transaction" );
s = fac.openSession();
t = s.beginTransaction();
if ( obj != null ) {
s.delete( getEmptyDatum( obj ) );
} else {
return false;
}
t.commit();
s.close();
System.out.println( "Delete returning true" );
return true;
} catch ( RuntimeException e ) {
e.printStackTrace();
System.err.println( "Commit failed!" );
if ( t != null && t.isActive() ) {
try {
t.rollback();
} catch ( HibernateException e1 ) {
System.err.println( "Rollback failed" );
}
}
}
System.out.println( "Delete returning false" );
return false;
}
@Override
public int delete( Collection<ObjBase> objs ) {
Session session = null;
Transaction transaction = null;
int succeeded = 0;
try {
session = fac.openSession();
transaction = session.beginTransaction();
for ( ObjBase obj : objs ) {
Object toDelete = getEmptyDatum( obj );
if ( toDelete != null ) {
session.delete( toDelete );
succeeded++;
}
}
transaction.commit();
session.close();
} catch ( RuntimeException e ) {
e.printStackTrace();
System.err.println( "Commit failed!" );
if ( transaction != null && transaction.isActive() ) {
try {
transaction.rollback();
return 0;
} catch ( HibernateException e1 ) {
session.close();
System.err.println( "Rollback failed" );
}
}
}
return succeeded;
}
/**
* Retrieves an ObjBase object from the database using a uuid
* @param type
* @param uuid
* @return
*/
@Override
public ObjBase get( ObjType type, String uuid ) {
Session s = fac.openSession();
hibernateDatum d = getHibernateDatum( type, uuid, s );
ObjBase result = null;
if ( d != null ) {
result = d.getObject();
SearchtagTable.pullSearchTags( result );
}
s.close();
return result;
}
@Override
public Collection<ObjBase> get( String hibQuery ) {
Collection<ObjBase> objs = new ArrayList<ObjBase>();
Session s = fac.openSession();
Transaction transaction = s.beginTransaction();
Query q = s.createQuery( hibQuery );
Iterator<hibernateDatum> results = q.iterate();
while ( results.hasNext() ) {
hibernateDatum d = results.next();
ObjBase obj = d.getObject();
SearchtagTable.pullSearchTags( obj );
objs.add( obj );
}
transaction.commit();
return objs;
}
@Override
public ArrayList<ObjLink> getAllLinks( ObjType type ) {
ArrayList<ObjLink> out = new ArrayList<ObjLink>();
System.out.println( "********* Getting all " + type.toString() + ":" );
Iterator collIT = findAll( type );
while ( collIT.hasNext() ) {
hibernateDatum datum = (hibernateDatum) collIT.next();
String name = datum.getName();
String uuid = datum.getUUID();
out.add( new ObjLink( uuid, type, name ) );
}
return out;
}
@Override
public String[][] getTableAsArray( ObjType type ) {
ArrayList<String[]> templist = new ArrayList<String[]>();
Iterator collIT = findAll( type );
while ( collIT.hasNext() ) {
hibernateDatum datum = (hibernateDatum) collIT.next();
String[] aline = new String[ 3 ];
aline[0] = datum.getUUID();
aline[1] = datum.getName();
switch ( type ) {
case FEATURE:
FeatureTable ft = (FeatureTable) datum;
aline[2] = ft.getNucseqTable().getSequence();
break;
default:
aline[2] = "";
}
templist.add( aline );
}
String[][] out = new String[ templist.size() ][ 3 ];
for ( int i = 0; i < templist.size(); i++ ) {
out[i] = templist.get( i );
}
return out;
}
/**
* Returns all the objects of the given type.
* @param type - Object keyword
* @return - Iterator giving results
*/
private Iterator<hibernateDatum> findAll( ObjType type ) {
Session session = null;
Transaction transaction = null;
session = fac.openSession();
Transaction t = session.beginTransaction();
String tabletoprobe = getObjectTranslation( type );
System.out.println( "Probing " + tabletoprobe );
Query q = session.createQuery( "from " + tabletoprobe );
Iterator<hibernateDatum> it = q.iterate();
t.commit();
return it;
}
/**
* JCA added this. Used for queries within the connection.
* @param hibQuery
* @return
*/
public Iterator query( String hibQuery ) {
Session session = null;
Transaction transaction = null;
session = fac.openSession();
activeSession = session;
Transaction t = session.beginTransaction();
Query q = session.createQuery( hibQuery );
Iterator it = q.iterate();
t.commit();
return it;
}
@Override
public void init() {
// In the future, add preference loading and such
}
public void configure() {
// _configurationViewer = new ConfigurationView( this );
// _configurationViewer.setVisible( true );
}
@Override
public Date getTimeModified( ObjBase obj ) {
String query = "";
//JCA: I have this if here since there is a typo in the field name of nucseq. Worth fixing eventually.
if ( obj.getType().equals( ObjType.NUCSEQ ) ) {
query = "select lastmodified from " + getObjectTranslation( obj.getType() ) + " where id='" + obj.getUUID() + "'";
} else {
query = "select lastModified from " + getObjectTranslation( obj.getType() ) + " where id='" + obj.getUUID() + "'";
}
Session session = null;
Transaction transaction = null;
try {
session = fac.openSession();
transaction = session.beginTransaction();
Date lastMod = (Date) session.createQuery( query ).uniqueResult();
transaction.commit();
session.close();
return lastMod;
} catch ( RuntimeException e ) {
e.printStackTrace();
return null;
}
}
@Override
public ClothoConnection.ClothoQuery createQuery( ObjType type ) {
return new HibernateQuery( type );
}
/**
* Use this to get a datum object built from a given ObjBase object. The
* resulting hibernateDatum object can be saved using hibernate. There should be one
* case here for each API type that is valid.
* @param obj
* @return
*/
hibernateDatum getHibernateDatum( ObjBase obj, Session s ) {
if ( obj == null ) {
return null;
}
switch ( obj.getType() ) {
case ANNOTATION:
return new NucseqAnnotation( (Annotation) obj );
case ATTACHMENT:
return new AttachmentTable( (Attachment) obj );
case COLLECTION:
return new CollectionTable( (org.clothocore.api.data.Collection) obj );
case CONTAINER:
return new ContainerTable( (Container) obj );
case FACTOID:
return new FactoidTable( (Factoid) obj );
case FAMILY:
return new FamilyTable( (Family) obj );
case FEATURE:
return new FeatureTable( (Feature) obj );
case FLEX_FIELD:
return new FlexfieldTable( (FlexField) obj );
case FORMAT:
return new FormatTable( (Format) obj );
case GRAMMAR:
return new GrammarTable( (Grammar) obj );
case INSTITUTION:
return new InstitutionTable( (Institution) obj );
case LAB:
return new LabTable( (Lab) obj );
case NUCSEQ:
return new NucseqTable( (NucSeq) obj );
case NOTE:
return new NoteTable( (Note) obj );
case OLIGO:
return new OligoTable( (Oligo) obj );
case PART:
// ASSERT: never reached, because parts are handled differently
return new PartTable( (Part) obj );
case PERSON:
return new PersonTable( (Person) obj );
case PLASMID:
return new PlasmidTable( (Plasmid) obj );
case PLATE:
return new PlateTable( (Plate) obj );
case PLATE_TYPE:
return new PlateTypeTable( (PlateType) obj );
case SAMPLE:
return new SampleTable( (Sample) obj );
case SAMPLE_DATA:
return new SampleDataTable( (SampleData) obj );
case STRAIN:
return new StrainTable( (Strain) obj );
case WIKITEXT:
return new WikitextTable( (WikiText) obj );
case VECTOR:
return new VectorTable( (Vector) obj );
default:
return null;
}
}
/**
* Use this to create an empty hibernateDatum object for the purpose of deleting or
* saving a link. The returned hibernateDatum will be of the right type and only
* have its UUID field filled in.
* @param obj
* @return
*/
hibernateDatum getEmptyDatum( ObjBase obj ) {
if ( obj == null ) {
return null;
}
switch ( obj.getType() ) {
case ANNOTATION:
return new NucseqAnnotation( obj.getUUID() );
case ATTACHMENT:
return new AttachmentTable( obj.getUUID() );
case COLLECTION:
return new CollectionTable( obj.getUUID() );
case CONTAINER:
return new ContainerTable( obj.getUUID() );
case FACTOID:
return new FactoidTable( obj.getUUID() );
case FAMILY:
return new FamilyTable( obj.getUUID() );
case FEATURE:
return new FeatureTable( obj.getUUID() );
case FLEX_FIELD:
return new FlexfieldTable( obj.getUUID() );
case FORMAT:
return new FormatTable( obj.getUUID() );
case GRAMMAR:
return new GrammarTable( obj.getUUID() );
case INSTITUTION:
return new InstitutionTable( obj.getUUID() );
case LAB:
return new LabTable( obj.getUUID() );
case NUCSEQ:
return new NucseqTable( obj.getUUID() );
case NOTE:
return new NoteTable( obj.getUUID() );
case OLIGO:
return new OligoTable( obj.getUUID() );
case PART:
return new PartTable( obj.getUUID() );
case PERSON:
return new PersonTable( obj.getUUID() );
case PLASMID:
return new PlasmidTable( obj.getUUID() );
case PLATE:
return new PlateTable( obj.getUUID() );
case PLATE_TYPE:
return new PlateTypeTable( obj.getUUID() );
case SAMPLE:
return new SampleTable( obj.getUUID() );
case SAMPLE_DATA:
return new SampleDataTable( obj.getUUID() );
case STRAIN:
return new StrainTable( obj.getUUID() );
case WIKITEXT:
return new WikitextTable( obj.getUUID() );
case VECTOR:
return new VectorTable( obj.getUUID() );
default:
return null;
}
}
/**
* Use this to get the datum object of the given type from the database. The
* resulting object can be used to create an ObjBase object to return, or to
* update an existing ObjBase object.
*
* openSession specifies whether this method needs to open a session, or whether
* a session has already been opened outside this method.
* @param type
* @param uuid
* @param openSession
* @return
*/
hibernateDatum getHibernateDatum( ObjType type, String uuid, Session session ) {
try {
boolean openedSession = false;
if ( session == null ) {
session = fac.openSession();
openedSession = true;
}
Transaction transaction = session.beginTransaction();
Query q = session.createQuery( "from " + getObjectTranslation( type ) + " where id='" + uuid + "'" );
hibernateDatum d = (hibernateDatum) q.uniqueResult();
transaction.commit();
if ( openedSession ) {
session.close();
}
return d;
} catch ( Throwable e ) {
System.err.println( e ); // TODO: do some error output
e.printStackTrace();
return null;
}
}
/**
* Returns a select query for the given ObjBase, assuming its in the database.
* Uses the uuid of the given object along with its type to build the query.
* @param obj
* @return
*/
String getSelectQuery( ObjBase obj ) {
String uuid = obj.getUUID();
if ( uuid == null ) {
return null;
}
String typeTranslation = getObjectTranslation( obj.getType() );
if ( typeTranslation == null ) {
return null;
}
return "from " + typeTranslation + " where id='" + uuid + "'";
}
/**
* Returns the database translation for the given type
* @param type
* @return
*/
@Override
public String getObjectTranslation( ObjType type ) {
switch ( type ) {
case ANNOTATION:
return "NucseqAnnotation";
case ATTACHMENT:
return "AttachmentTable";
case COLLECTION:
return "CollectionTable";
case CONTAINER:
return "ContainerTable";
case FACTOID:
return "FactoidTable";
case FAMILY:
return "FamilyTable";
case FEATURE:
return "FeatureTable";
case FLEX_FIELD:
return "FlexFieldTable";
case FORMAT:
return "FormatTable";
case GRAMMAR:
return "GrammarTable";
case INSTITUTION:
return "InstitutionTable";
case LAB:
return "LabTable";
case NUCSEQ:
return "NucseqTable";
case NOTE:
return "NoteTable";
case OLIGO:
return "OligoTable";
case PART:
return "PartTable";
case PERSON:
return "PersonTable";
case PLASMID:
return "PlasmidTable";
case PLATE:
return "PlateTable";
case PLATE_TYPE:
return "PlateTypeTable";
case SAMPLE:
return "SampleTable";
case SAMPLE_DATA:
return "SampleDataTable";
case STRAIN:
return "StrainTable";
case VECTOR:
return "VectorTable";
case WIKITEXT:
return "WikitextTable";
default:
return null;
}
}
/**
* Returns the field name of the given field type of the given object type.
* This isn'transaction needed except for the HibernateQuery type searching of the database.
* @param type
* @param field
* @return
*/
@Override
public String getFieldTranslation( ObjType type, Enum field ) {
String translation = null;
System.out.println("getfieldTranslation of " + type + field);
switch ( type ) {
case ANNOTATION:
translation = NucseqAnnotation.translate( field );
break;
case ATTACHMENT:
translation = AttachmentTable.translate( field );
break;
case COLLECTION:
translation = CollectionTable.translate( field );
break;
case CONTAINER:
translation = ContainerTable.translate( field );
break;
case FACTOID:
translation = FactoidTable.translate( field );
break;
case FAMILY:
translation = FamilyTable.translate( field );
break;
case FEATURE:
translation = FeatureTable.translate( field );
break;
case FLEX_FIELD:
translation = FlexfieldTable.translate( field );
break;
case FORMAT:
translation = FormatTable.translate( field );
break;
case GRAMMAR:
translation = GrammarTable.translate( field );
break;
case INSTITUTION:
translation = InstitutionTable.translate( field );
break;
case LAB:
translation = LabTable.translate( field );
break;
case NOTE:
translation = NoteTable.translate( field );
break;
case NUCSEQ:
translation = NucseqTable.translate( field );
break;
case OLIGO:
translation = OligoTable.translate( field );
break;
case PART:
translation = PartTable.translate( field );
break;
case PERSON:
translation = PersonTable.translate( field );
break;
case PLASMID:
translation = PlasmidTable.translate( field );
break;
case PLATE:
translation = PlateTable.translate( field );
break;
case PLATE_TYPE:
translation = PlateTypeTable.translate( field );
break;
case SAMPLE:
translation = SampleTable.translate( field );
break;
case SAMPLE_DATA:
translation = SampleDataTable.translate( field );
break;
case STRAIN:
translation = StrainTable.translate( field );
break;
case VECTOR:
translation = VectorTable.translate( field );
break;
case WIKITEXT:
translation = WikitextTable.translate( field );
break;
default:
translation = null;
}
if ( translation == null ) {
// TODO: signal an error somehow, but this should never happen
}
return translation;
}
public ObjType getFieldType( ObjType type, Enum field ) {
switch ( type ) {
case ANNOTATION:
return NucseqAnnotation.getType( field );
case ATTACHMENT:
return AttachmentTable.getType( field );
case COLLECTION:
return CollectionTable.getType( field );
case CONTAINER:
return ContainerTable.getType( field );
case FACTOID:
return FactoidTable.getType( field );
case FAMILY:
return FamilyTable.getType( field );
case FEATURE:
return FeatureTable.getType( field );
case FLEX_FIELD:
return FlexfieldTable.getType( field );
case FORMAT:
return FormatTable.getType( field );
case GRAMMAR:
return GrammarTable.getType( field );
case INSTITUTION:
return InstitutionTable.getType( field );
case LAB:
return LabTable.getType( field );
case NOTE:
return NoteTable.getType( field );
case NUCSEQ:
return NucseqTable.getType( field );
case OLIGO:
return OligoTable.getType( field );
case PART:
return PartTable.getType( field );
case PERSON:
return PersonTable.getType( field );
case PLASMID:
return PlasmidTable.getType( field );
case PLATE:
return PlateTable.getType( field );
case PLATE_TYPE:
return PlateTypeTable.getType( field );
case SAMPLE:
return SampleTable.getType( field );
case SAMPLE_DATA:
return SampleDataTable.getType( field );
case STRAIN:
return StrainTable.getType( field );
case VECTOR:
return VectorTable.getType( field );
case WIKITEXT:
return WikitextTable.getType( field );
default:
return null;
}
}
/**************** PRIVATE VARIABLES ****************/
private SessionFactory fac;
private Session activeSession = null;
private static FileFilter configFileFilter = new FileFilter() {
public boolean accept( File pathname ) {
return pathname.getName().endsWith( ".cfg.xml" );
}
@Override
public String getDescription() {
return "Filters for Hibernate Configuration Files";
}
};
public static HibernateConnection connection;
/* Preference enums */
public enum PreferenceKeys {
CONFIG_DIRECTORY,
}
/***************************************************************************
***************************** Inner Class **********************************
***************************************************************************/
class HibernateQuery implements ClothoConnection.ClothoQuery {
private Criteria criteria;
private ObjType type;
private Session session;
HibernateQuery( ObjType type ) {
session = fac.openSession();
this.type = type;
switch ( type ) {
case ATTACHMENT:
criteria = session.createCriteria( AttachmentTable.class );
break;
case COLLECTION:
criteria = session.createCriteria( CollectionTable.class );
break;
case CONTAINER:
criteria = session.createCriteria( ContainerTable.class );
break;
case FACTOID:
criteria = session.createCriteria( FactoidTable.class );
break;
case FAMILY:
criteria = session.createCriteria( FamilyTable.class );
break;
case FEATURE:
criteria = session.createCriteria( FeatureTable.class );
break;
case FLEX_FIELD:
criteria = session.createCriteria( FlexfieldTable.class );
break;
case FORMAT:
criteria = session.createCriteria( FormatTable.class );
break;
case GRAMMAR:
criteria = session.createCriteria( GrammarTable.class );
break;
case INSTITUTION:
criteria = session.createCriteria( InstitutionTable.class );
break;
case LAB:
criteria = session.createCriteria( LabTable.class );
break;
case NOTE:
criteria = session.createCriteria( NoteTable.class );
break;
case NUCSEQ:
criteria = session.createCriteria( NucseqTable.class );
break;
case OLIGO:
criteria = session.createCriteria( OligoTable.class );
break;
case PART:
criteria = session.createCriteria( PartTable.class );
break;
case PERSON:
criteria = session.createCriteria( PersonTable.class );
break;
case PLASMID:
criteria = session.createCriteria( PlasmidTable.class );
break;
case PLATE:
criteria = session.createCriteria( PlateTable.class );
break;
case PLATE_TYPE:
criteria = session.createCriteria( PlateTypeTable.class );
break;
case SAMPLE:
criteria = session.createCriteria( SampleTable.class );
break;
case SAMPLE_DATA:
criteria = session.createCriteria( SampleDataTable.class );
break;
case STRAIN:
criteria = session.createCriteria( StrainTable.class );
break;
case VECTOR:
criteria = session.createCriteria( VectorTable.class );
break;
case WIKITEXT:
criteria = session.createCriteria( WikitextTable.class );
break;
default:
System.err.println( "Unrecognized type" ); // TODO: Change this to a warning dialog
}
}
private HibernateQuery( ObjType t, Criteria crit ) {
type = t;
criteria = crit;
}
@Override
public ClothoConnection.ClothoQuery setMaxResults( int max ) {
criteria = criteria.setMaxResults( max );
return this;
}
@Override
public ClothoConnection.ClothoQuery between( Enum field, Object hi, Object lo ) {
criteria = criteria.add( Restrictions.between( getFieldTranslation( type, field ), lo, hi ) );
return this;
}
@Override
public ClothoConnection.ClothoQuery lessThan( Enum field, Object hi ) {
criteria = criteria.add( Restrictions.lt( getFieldTranslation( type, field ), hi ) );
return this;
}
@Override
public ClothoConnection.ClothoQuery greaterThan( Enum field, Object lo ) {
criteria = criteria.add( Restrictions.gt( getFieldTranslation( type, field ), lo ) );
return this;
}
@Override
public ClothoConnection.ClothoQuery equal( Enum field, Object value ) {
criteria = criteria.add( Restrictions.eq( getFieldTranslation( type, field ), value ) );
return this;
}
@Override
public ClothoConnection.ClothoQuery eq( Enum field, Object value ) {
return equal( field, value );
}
@Override
public ClothoConnection.ClothoQuery notEqual( Enum field, Object value ) {
criteria = criteria.add( Restrictions.ne( getFieldTranslation( type, field ), value ) );
return this;
}
@Override
public ClothoConnection.ClothoQuery neq( Enum field, Object value ) {
return notEqual( field, value );
}
@Override
public ClothoConnection.ClothoQuery isNull( Enum field ) {
criteria = criteria.add( Restrictions.isNull( getFieldTranslation( type, field ) ) );
return this;
}
@Override
public ClothoConnection.ClothoQuery isNotNull( Enum field ) {
criteria = criteria.add( Restrictions.isNotNull( getFieldTranslation( type, field ) ) );
return this;
}
@Override
public ClothoConnection.ClothoQuery matches( Enum field, String value, boolean caseSensitive ) {
if ( caseSensitive ) {
criteria = criteria.add( Restrictions.like( getFieldTranslation( type, field ), value ) );
} else {
criteria = criteria.add( Restrictions.ilike( getFieldTranslation( type, field ), value ) );
}
return this;
}
@Override
public ClothoConnection.ClothoQuery contains( Enum field, String value, boolean caseSensitive ) {
if ( value.charAt( 0 ) != '%' ) {
value = "%" + value;
}
if ( value.charAt( value.length() - 1 ) != '%' ) {
value = value + "%";
}
if ( caseSensitive ) {
criteria = criteria.add( Restrictions.like( getFieldTranslation( type, field ), value ) );
} else {
criteria = criteria.add( Restrictions.ilike( getFieldTranslation( type, field ), value ) );
}
return this;
}
@Override
public List<ObjBase> getResults() {
if ( !session.isOpen() ) {
System.out.println( "HibernateConnectionPlugin returning null since session isn't open" );
return null; // This method should only be called once!
}
List<ObjBase> results = new ArrayList<ObjBase>();
List<hibernateDatum> datums = criteria.list();
for ( hibernateDatum d : datums ) {
ObjBase obj = d.getObject();
SearchtagTable.pullSearchTags( obj );
results.add( obj );
}
session.close();
return results;
}
@Override
public ClothoConnection.ClothoQuery add( ClothoConnection.ClothoCriterion crit ) {
if ( crit != null && crit.getClass().equals( HibernateCriterion.class ) ) {
criteria = criteria.add( ((HibernateCriterion) crit)._myCriterion );
}
return this;
}
@Override
public ClothoConnection.ClothoCriterion or( Collection<ClothoConnection.ClothoCriterion> criteria ) {
Iterator<ClothoConnection.ClothoCriterion> it = criteria.iterator();
Disjunction d = Restrictions.disjunction();
while ( it.hasNext() ) {
ClothoConnection.ClothoCriterion cc = it.next();
if ( it.getClass().equals( HibernateCriterion.class ) ) {
d.add( ((HibernateCriterion) cc)._myCriterion );
}
}
return new HibernateCriterion( d );
}
@Override
public ClothoConnection.ClothoCriterion or( ClothoConnection.ClothoCriterion a, ClothoConnection.ClothoCriterion b ) {
if ( !a.getClass().equals( HibernateCriterion.class )
|| !b.getClass().equals( HibernateCriterion.class ) ) {
return null;
}
HibernateCriterion ha = (HibernateCriterion) a,
hb = (HibernateCriterion) b;
Disjunction d = Restrictions.disjunction();
d.add( ha._myCriterion ).add( hb._myCriterion );
return new HibernateCriterion( d );
}
@Override
public ClothoConnection.ClothoCriterion and( Collection<ClothoConnection.ClothoCriterion> criteria ) {
Iterator<ClothoConnection.ClothoCriterion> it = criteria.iterator();
Conjunction d = Restrictions.conjunction();
while ( it.hasNext() ) {
ClothoConnection.ClothoCriterion cc = it.next();
if ( it.getClass().equals( HibernateCriterion.class ) ) {
d.add( ((HibernateCriterion) cc)._myCriterion );
}
}
return new HibernateCriterion( d );
}
@Override
public ClothoConnection.ClothoCriterion and( ClothoConnection.ClothoCriterion a, ClothoConnection.ClothoCriterion b ) {
if ( a == null || b == null
|| !a.getClass().equals( HibernateCriterion.class )
|| !b.getClass().equals( HibernateCriterion.class ) ) {
return null;
}
HibernateCriterion ha = (HibernateCriterion) a,
hb = (HibernateCriterion) b;
Conjunction d = Restrictions.conjunction();
d.add( ha._myCriterion ).add( hb._myCriterion );
return new HibernateCriterion( d );
}
@Override
public ClothoConnection.ClothoCriterion not( ClothoConnection.ClothoCriterion c ) {
if ( c != null && c.getClass().equals( HibernateCriterion.class ) ) {
return new HibernateCriterion(
Restrictions.not( ((HibernateCriterion) c)._myCriterion ) );
}
return null;
}
@Override
public ClothoConnection.ClothoCriterion getBetweenCrit( Enum field, Object hi, Object lo ) {
String f = getFieldTranslation( type, field );
Criterion c = Restrictions.between( f, lo, hi );
return new HibernateCriterion( c );
}
@Override
public ClothoConnection.ClothoCriterion getLessThanCrit( Enum field, Object hi ) {
String f = getFieldTranslation( type, field );
Criterion c = Restrictions.lt( f, hi );
return new HibernateCriterion( c );
}
@Override
public ClothoConnection.ClothoCriterion getGreaterThanCrit( Enum field, Object lo ) {
String f = getFieldTranslation( type, field );
Criterion c = Restrictions.gt( f, lo );
return new HibernateCriterion( c );
}
@Override
public ClothoConnection.ClothoCriterion getEqualCrit( Enum field, Object value ) {
String f = getFieldTranslation( type, field );
Criterion c = Restrictions.eq( f, value );
return new HibernateCriterion( c );
}
@Override
public ClothoConnection.ClothoCriterion getNotEqualCrit( Enum field, Object value ) {
String f = getFieldTranslation( type, field );
Criterion c = Restrictions.ne( f, value );
return new HibernateCriterion( c );
}
@Override
public ClothoConnection.ClothoCriterion getIsNullCrit( Enum field ) {
String f = getFieldTranslation( type, field );
Criterion c = Restrictions.isNull( f );
return new HibernateCriterion( c );
}
@Override
public ClothoConnection.ClothoCriterion getIsNotNullCrit( Enum field ) {
String f = getFieldTranslation( type, field );
Criterion c = Restrictions.isNotNull( f );
return new HibernateCriterion( c );
}
@Override
public ClothoConnection.ClothoCriterion getMatchesCrit( Enum field, Object value ) {
String f = getFieldTranslation( type, field );
Criterion c = Restrictions.ilike( f, value );
return new HibernateCriterion( c );
}
@Override
public ObjType getType() {
return type;
}
@Override
public ClothoQuery createAssociationQuery( Enum field ) {
return new HibernateQuery( getFieldType( type, field ), criteria.createCriteria( getFieldTranslation( type, field ) ) );
}
}
class HibernateCriterion extends ClothoConnection.ClothoCriterion {
Criterion _myCriterion;
protected HibernateCriterion( Criterion c ) {
_myCriterion = c;
}
}
}