Java tutorial
/* * EuroCarbDB, a framework for carbohydrate bioinformatics * * Copyright (c) 2006-2009, Eurocarb project, or third-party contributors as * indicated by the @author tags or express copyright attribution * statements applied by the authors. * * This copyrighted material is made available to anyone wishing to use, modify, * copy, or redistribute it subject to the terms and conditions of the GNU * Lesser General Public License, as published by the Free Software Foundation. * A copy of this license accompanies this distribution in the file LICENSE.txt. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License * for more details. * * Last commit: $Rev: 1210 $ by $Author: glycoslave $ on $Date:: 2009-06-12 #$ */ package org.eurocarbdb.resourcesdb.io; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import org.eurocarbdb.resourcesdb.*; import org.eurocarbdb.resourcesdb.atom.*; import org.eurocarbdb.resourcesdb.monosaccharide.*; import org.eurocarbdb.resourcesdb.nonmonosaccharide.*; import org.eurocarbdb.resourcesdb.representation.ResidueRepresentation; import org.eurocarbdb.resourcesdb.template.SubstituentTemplate; import org.eurocarbdb.resourcesdb.template.*; import org.eurocarbdb.resourcesdb.util.HibernateUtil; import org.hibernate.*; import org.hibernate.criterion.*; /** * This class stores the methods to access the database via hibernate. * It was introduced to separate the database access from the actual residue objects for easy generation of "hibernate-free" standalone versions for use in Applets. * * @author Thomas Ltteke */ public class HibernateAccess { // ***************************************************************************** // *** Elements data: ********************************************************** // ***************************************************************************** public static boolean writeElementsToDB() throws ResourcesDbException { //*** store elements in db: *** Session hbSession = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = hbSession.beginTransaction(); try { for (Periodic elem : Periodic.values()) { System.out.println("write element " + elem.getSymbol() + "..."); hbSession.save(elem); for (Isotope iso : elem.getIsotopes()) { System.out.println(" write isotope " + iso.getNeutrons() + "..."); hbSession.save(iso); } } hbSession.getTransaction().commit(); } catch (Exception e) { System.err.println(e); tx.rollback(); return (false); } return (true); } @SuppressWarnings("unchecked") public static ArrayList<Periodic> getElementListFromDB() { ArrayList<Periodic> resultList = null; Session hbSession = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = hbSession.beginTransaction(); try { resultList = (ArrayList<Periodic>) hbSession.createQuery("from Element").list(); } catch (Exception e) { tx.rollback(); } return resultList; } // ***************************************************************************** // *** Basetype data: ********************************************************** // ***************************************************************************** public static boolean writeBasetypeToDB(Basetype bt, BasetypeTemplateContainer container) { return writeBasetypeToDB(bt, container, true); } public static boolean writeBasetypeToDB(Basetype bt, BasetypeTemplateContainer container, boolean commit) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { if (bt.getName() == null) { bt.buildName(); } if (bt.getSuperclass() == null) { bt.setSuperclass(container.getSuperclassTemplateBySize(bt.getSize()).getBaseName()); } if (bt.getIsSuperclassFlag() == null) { bt.checkIsSuperclass(); } if (bt.getComposition() == null) { bt.buildComposition(); } session.save(bt); for (CoreModification mod : bt.getCoreModifications()) { session.save(mod); } if (bt.getAtoms() == null) { bt.buildAtoms(); } for (Atom a : bt.getAtoms()) { session.save("BasetypeAtom", a); } for (Atom a : bt.getAtoms()) { for (AtomConnection ac : a.getConnections()) { session.save("BasetypeAtomConnection", ac); } } if (commit) { tx.commit(); } } catch (Exception e) { tx.rollback(); System.err.println("Exception in HibernateAccess.writeBasetypeToDB(bt): " + e); return (false); } return (true); } public static Basetype getBasetypeFromDB(String name) { Basetype bt = null; Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { bt = (Basetype) session.createQuery("from Basetype where name='" + name + "'").uniqueResult(); } catch (Exception e) { tx.rollback(); } return (bt); } public static Basetype getBasetypeFromDB(int id) { Basetype bt = null; Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { bt = (Basetype) session.createQuery("from Basetype where id=" + id).uniqueResult(); } catch (Exception e) { tx.rollback(); } return (bt); } public static Basetype storeOrUpdateBasetype(Basetype bt, BasetypeTemplateContainer container) throws ResourcesDbException { return storeOrUpdateBasetype(bt, container, true); } public static Basetype storeOrUpdateBasetype(Basetype bt, BasetypeTemplateContainer container, boolean commit) throws ResourcesDbException { if (bt.getName() == null) { bt.buildName(); } Basetype dbBasetype = HibernateAccess.getBasetypeFromDB(bt.getName()); if (dbBasetype == null) { //*** basetype not yet present in DB *** HibernateAccess.writeBasetypeToDB(bt, container, commit); return (bt); } return (dbBasetype); } // ***************************************************************************** // *** Monosaccharide data: **************************************************** // ***************************************************************************** /** * Get a monosaccharide from the database identified by name * @param name the name of the monosaccharide * @return the monosaccharide */ public static Monosaccharide getMonosaccharideFromDB(String name) { Monosaccharide ms = null; Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { ms = (Monosaccharide) session.createQuery("from Monosaccharide where name='" + name + "'") .uniqueResult(); } catch (Exception e) { tx.rollback(); } return (ms); } /** * Get a monosaccharide from the database identified by the database id * @param id the database id of the monosaccharide * @return the monosaccharide */ public static Monosaccharide getMonosaccharideFromDB(int id) { Monosaccharide ms = null; Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { ms = (Monosaccharide) session.createQuery("from Monosaccharide where id=" + id).uniqueResult(); } catch (Exception e) { tx.rollback(); } return (ms); } /** * Get a list of monosaccharides from the database that match the properties of a given monosaccharide. * If the given monosaccharide contains unknown properties, they are ignored in the search. * @param mono the monosaccharide that defines the search parameters * @return a list of monosaccharides matching the given one */ public static ArrayList<Monosaccharide> getMonosaccharideListByFuzzyMonosaccharide(Monosaccharide mono) { return getMonosaccharideListByFuzzyMonosaccharide(mono, true, true); } public static ArrayList<Monosaccharide> getMonosaccharideListByFuzzyMonosaccharide(Monosaccharide mono, boolean matchCoremodCount, boolean matchSubstCount) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); //*** prepare Criteria object: *** Criteria query = session.createCriteria(Monosaccharide.class); query.createAlias("basetype", "bt"); if (mono.countCoreModifications() > 0) { query.createAlias("bt.coreModifications", "mod"); } if (mono.countSubstitutions() > 0) { query.createAlias("substitutions", "subst", Criteria.LEFT_JOIN); } //*** add restrictions: *** Conjunction monoJunc = Restrictions.conjunction(); query.add(monoJunc); //*** size restriction: *** if (mono.getSize() > 0) { monoJunc.add(Restrictions.eq("bt.size", mono.getSize())); } //*** stereocode restrictions: *** if (mono.getStereoStr() != null && mono.getStereoStr().length() > 0) { String stereo1 = null; String stereo2 = null; if (mono.getStereocode().hasRelativePosition()) { try { stereo1 = Stereocode.relativeToAbsolute(mono.getStereoStr()); stereo2 = Stereocode .relativeToAbsolute(Stereocode.changeRelativeDLinStereoString(mono.getStereoStr())); stereo2 = stereo2.replaceAll("" + Stereocode.StereoX, "_"); } catch (ResourcesDbException me) { //*** stereocode causes problems, doesn't make sense to use it for search then, therefore nothing needs to be done here *** if (Config.getGlobalConfig().isPrintErrorMsgs()) { System.err.println(me); me.printStackTrace(); } } } else { stereo1 = mono.getStereoStr(); } if (stereo1 != null) { stereo1 = stereo1.replaceAll("" + Stereocode.StereoX, "_"); if (stereo2 != null) { monoJunc.add(Restrictions.disjunction().add(Restrictions.like("bt.stereoStr", stereo1)) .add(Restrictions.like("bt.stereoStr", stereo2))); } else { monoJunc.add(Restrictions.like("bt.stereoStr", stereo1)); } } } //*** anomeric restriction: *** if (mono.getAnomer() != null && !mono.getAnomer().equals(Anomer.UNKNOWN)) { monoJunc.add(Restrictions.eq("bt.anomerSymbol", mono.getAnomer().getSymbol())); } //*** ring restrictions: *** if (mono.getRingStart() != Basetype.UNKNOWN_RING) { monoJunc.add(Restrictions.eq("bt.ringStart", mono.getRingStart())); } if (mono.getRingEnd() != Basetype.UNKNOWN_RING) { monoJunc.add(Restrictions.eq("bt.ringEnd", mono.getRingEnd())); } //*** core modification restrictions: *** if (mono.countCoreModifications() > 0) { Conjunction modListConjunct = Restrictions.conjunction(); for (CoreModification mod : mono.getCoreModifications()) { Conjunction modConjunct = Restrictions.conjunction(); modConjunct.add(Restrictions.eq("mod.name", mod.getName())); if (mod.getPosition1().size() > 1) { Disjunction modPos1Disjunct = Restrictions.disjunction(); for (Integer pos1 : mod.getPosition1()) { if (pos1.intValue() != 0) { modPos1Disjunct.add(Restrictions.eq("mod.intValuePosition1", pos1)); } } modConjunct.add(modPos1Disjunct); } else if (mod.getIntValuePosition1() > 0) { modConjunct.add(Restrictions.eq("mod.intValuePosition1", mod.getIntValuePosition1())); } if (mod.hasPosition2()) { if (mod.getPosition2().size() > 1) { Disjunction modPos2Disjunct = Restrictions.disjunction(); for (Integer pos2 : mod.getPosition2()) { if (pos2.intValue() != 0) { modPos2Disjunct.add(Restrictions.eq("mod.intValuePosition2", pos2)); } } modConjunct.add(modPos2Disjunct); } else if (mod.getIntValuePosition2() > 0) { modConjunct.add(Restrictions.eq("mod.intValuePosition2", mod.getIntValuePosition2())); } } modListConjunct.add(modConjunct); } monoJunc.add(modListConjunct); } //*** substitution restrictions: *** if (mono.countSubstitutions() > 0) { Conjunction substListConjunct = Restrictions.conjunction(); for (Substitution subst : mono.getSubstitutions()) { Conjunction substConjunct = Restrictions.conjunction(); substConjunct.add(Restrictions.eq("subst.name", subst.getName())); if (subst.getPosition1().size() > 1) { Disjunction substPos1Disjunct = Restrictions.disjunction(); for (Integer pos1 : subst.getPosition1()) { if (pos1.intValue() != 0) { substPos1Disjunct.add(Restrictions.eq("subst.intValuePosition1", pos1)); } } substConjunct.add(substPos1Disjunct); } else if (subst.getIntValuePosition1() > 0) { substConjunct.add(Restrictions.eq("subst.intValuePosition1", subst.getIntValuePosition1())); } if (subst.getLinkagetype1() != null) { substConjunct.add(Restrictions.eq("subst.linkagetypeStr1", subst.getLinkagetypeStr1())); } if (subst.hasPosition2()) { if (subst.getPosition2().size() > 1) { Disjunction substPos2Disjunct = Restrictions.disjunction(); for (Integer pos2 : subst.getPosition2()) { if (pos2.intValue() != 0) { substPos2Disjunct.add(Restrictions.eq("subst.intValuePosition2", pos2)); } } substConjunct.add(substPos2Disjunct); } else if (subst.getIntValuePosition2() > 0) { substConjunct.add(Restrictions.eq("subst.intValuePosition2", subst.getIntValuePosition2())); } if (subst.getLinkagetype2() != null) { substConjunct.add(Restrictions.eq("subst.linkagetypeStr2", subst.getLinkagetypeStr2())); } } substListConjunct.add(substConjunct); } monoJunc.add(substListConjunct); } //*** add "distinct": *** query.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); //System.out.println("query: " + query.toString()); //*** perform query: *** List<?> queryList = query.list(); //*** prepare result List: *** ArrayList<Monosaccharide> resultList = new ArrayList<Monosaccharide>(); Iterator<?> listIter = queryList.iterator(); while (listIter.hasNext()) { Monosaccharide resultMs = (Monosaccharide) listIter.next(); if (resultMs != null) { //TODO: include modification counts into criteria if (!matchCoremodCount || resultMs.countCoreModifications() == mono.countCoreModifications()) { if (!matchSubstCount || resultMs.countSubstitutions() == mono.countSubstitutions()) { resultList.add(resultMs); } } } } return resultList; } @SuppressWarnings("unchecked") public static List<Monosaccharide> getMonosaccharideListByAliasName(String aliasname, GlycanNamescheme scheme) { List<Monosaccharide> msList = null; Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { //*** prepare query: *** Criteria query = session.createCriteria(Monosaccharide.class); query.createAlias("synonyms", "alias"); //*** add restrictions: *** Conjunction monoJunc = Restrictions.conjunction(); query.add(monoJunc); if (scheme == null || scheme.isCaseSensitive()) { monoJunc.add(Restrictions.like("alias.name", aliasname)); } else { monoJunc.add(Restrictions.ilike("alias.name", aliasname)); } if (scheme != null && !scheme.equals(GlycanNamescheme.AUTO)) { monoJunc.add(Restrictions.eq("alias.nameschemeStr", scheme.name())); } //*** add "distinct": *** query.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); //*** perform query: *** msList = (List<Monosaccharide>) query.list(); } catch (Exception e) { tx.rollback(); } return (msList); } public static boolean writeMonosaccharideToDB(Monosaccharide ms, TemplateContainer container) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { //*** make sure monosaccharide and basetype names are set: *** if (ms.getName() == null) { ms.buildName(); } Basetype bt = ms.getBasetype(); if (bt.getName() == null) { bt.buildName(); } if (ms.getSynonyms() == null || ms.getSynonyms().size() == 0) { MonosaccharideDataBuilder.buildSynonyms(ms, container); } if (ms.getComposition() == null) { MonosaccharideDataBuilder.buildComposition(ms); } if (ms.getAtoms() == null || ms.getAtoms().size() == 0) { MonosaccharideDataBuilder.buildAtoms(ms, Config.getGlobalConfig()); } if (ms.getAtoms() == null || ms.getAtoms().size() == 0) { System.err.println("no atoms set in ms " + ms.toString()); return (false); } if (ms.getRepresentations() == null || ms.getRepresentations().size() == 0) { ms.buildRepresentations(); } //*** link basetype to db: *** ms.setBasetype( HibernateAccess.storeOrUpdateBasetype(bt, container.getBasetypeTemplateContainer(), false)); //*** save monosaccharide: *** System.out.println("store monosaccharide " + ms.getName()); session.save(ms); for (Substitution subst : ms.getSubstitutions()) { session.save("Substitution", subst); } for (Atom a : ms.getAtoms()) { session.save("MonosaccharideAtom", a); } for (Atom a : ms.getAtoms()) { for (AtomConnection ac : a.getConnections()) { session.save("MonosaccharideAtomConnection", ac); } } for (MonosaccharideSynonym alias : ms.getSynonyms()) { //System.out.println(" alias " + alias.toString()); if (alias.getName() == null) { continue; } session.save(alias); for (Substitution extSubst : alias.getExternalSubstList()) { session.save("MonosaccharideSynonymExternalSubstituent", extSubst); } } for (ResidueRepresentation monoRep : ms.getRepresentations()) { //System.out.println(" save representation " + monoRep.toString()); session.save("MonosaccharideRepresentation", monoRep); } for (MonosaccharideLinkingPosition linkPos : ms.getPossibleLinkingPositions()) { session.save(linkPos); } tx.commit(); Monosaccharide dbMs = HibernateAccess.getMonosaccharideFromDB(ms.getDbId()); System.out.println("stored ms with id " + dbMs.getDbId()); } catch (Exception e) { if (Config.getGlobalConfig().isPrintErrorMsgs()) { System.err.println("Exception in WriteMonosaccharideToDB(): " + e); e.printStackTrace(); } tx.rollback(); return (false); } return (true); } public static boolean updateMonosaccharide(Monosaccharide dbMs) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { session.update(dbMs); } catch (Exception e) { if (Config.getGlobalConfig().isPrintErrorMsgs()) { System.err.println("Exception in HibernateAccess.updateMonosaccharide(): " + e); e.printStackTrace(); } tx.rollback(); return (false); } return true; } public static Monosaccharide storeOrUpdateMonosaccharide(Monosaccharide ms, TemplateContainer container) throws ResourcesDbException { if (ms.getName() == null || ms.getName().equals("")) { ms.buildName(); } Monosaccharide dbMs = HibernateAccess.getMonosaccharideFromDB(ms.getName()); if (dbMs == null) { //*** monosaccharide not yet present in DB *** HibernateAccess.writeMonosaccharideToDB(ms, container); return (ms); } else { //TODO: update ms in database with e.g. additional synynoms, if present in ms for (ResidueRepresentation msRep : ms.getRepresentations()) { if (!dbMs.hasRepresentation(msRep.getType(), msRep.getFormat())) { dbMs.addRepresentation(msRep); System.out.println("store representation " + msRep.toString()); HibernateAccess.storeOrUpdateMonosaccharideRepresentation(msRep); } } } return (dbMs); } public static MonosaccharideSynonym storeOrUpdateMonosaccharideSynonym(MonosaccharideSynonym msAlias) throws ResourcesDbException { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { session.saveOrUpdate(msAlias); for (Substitution extSubst : msAlias.getExternalSubstList()) { session.saveOrUpdate("MonosaccharideSynonymExternalSubstituent", extSubst); } tx.commit(); } catch (Exception e) { tx.rollback(); throw new ResourcesDbException("Error in storing or updating monosaccharide alias", e); } return msAlias; } public static ResidueRepresentation storeOrUpdateMonosaccharideRepresentation(ResidueRepresentation monoRep) throws ResourcesDbException { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { session.saveOrUpdate("MonosaccharideRepresentation", monoRep); tx.commit(); } catch (Exception e) { tx.rollback(); MonosaccharideException me = new MonosaccharideException( "Error in storing or updating monosaccharide representation"); me.initCause(e); throw me; } return monoRep; } // ***************************************************************************** // *** Substituent Templates: ************************************************** // ***************************************************************************** private static void writeOrUpdateSingleSubstituentTemplateToDB(SubstituentTemplate substTmpl, Session openSession) { SubstituentTemplate dbTmpl = (SubstituentTemplate) openSession .createQuery("from SubstituentTemplate where name='" + substTmpl.getName() + "'").uniqueResult(); if (dbTmpl == null) { openSession.save(substTmpl); for (SubstituentAlias alias : substTmpl.getAliasList()) { openSession.save(alias); } for (Atom a : substTmpl.getAtoms()) { openSession.save("SubstituentAtom", a); } for (Atom a : substTmpl.getAtoms()) { for (AtomConnection ac : a.getConnections()) { openSession.save("SubstituentAtomConnection", ac); } } try { for (NonBasetypeLinkingPosition nlp : substTmpl.getValidLinkingPositions()) { openSession.save("ValidSubstituentLinkage", nlp); } } catch (ResourcesDbException me) { //*** exception is thrown when no valid linkage positions are given, nothing to do here in that case *** } } else { System.out.println("subst already present: " + dbTmpl.toString()); } } public static void writeSubstituentTemplatesToDB(SubstituentTemplateContainer container) throws ResourcesDbException { ArrayList<String> substTmplList = container.getResidueIncludedNameList(GlycanNamescheme.MONOSACCHARIDEDB); if (substTmplList == null) { System.err.println("subst template list is null"); return; } Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); for (String tmplName : container.getResidueIncludedNameList(GlycanNamescheme.MONOSACCHARIDEDB)) { SubstituentTemplate substTmpl = container.forName(GlycanNamescheme.MONOSACCHARIDEDB, tmplName); System.out.println("write substituent template " + substTmpl.getName()); writeOrUpdateSingleSubstituentTemplateToDB(substTmpl, session); } session.getTransaction().commit(); } public static SubstituentTemplate getSubstituentTemplateFromDB(String name) { SubstituentTemplate dbTmpl = null; Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { dbTmpl = (SubstituentTemplate) session.createQuery("from SubstituentTemplate where name='" + name + "'") .uniqueResult(); } catch (Exception e) { tx.rollback(); } return dbTmpl; } // ***************************************************************************** // *** Aglycon Templates: ****************************************************** // ***************************************************************************** private static void writeOrUpdateSingleAglyconTemplateToDB(AglyconTemplate aglTmpl, Session openSession) { AglyconTemplate dbTmpl = (AglyconTemplate) openSession .createQuery("from AglyconTemplate where name='" + aglTmpl.getName() + "'").uniqueResult(); if (dbTmpl == null) { openSession.save(aglTmpl); for (AglyconAlias alias : aglTmpl.getAliasList()) { openSession.save(alias); } for (Atom a : aglTmpl.getAtoms()) { openSession.save("AglyconAtom", a); } for (Atom a : aglTmpl.getAtoms()) { for (AtomConnection ac : a.getConnections()) { openSession.save("AglyconAtomConnection", ac); } } try { for (NonBasetypeLinkingPosition nlp : aglTmpl.getValidLinkingPositions()) { openSession.save("ValidAglyconLinkage", nlp); } } catch (ResourcesDbException me) { //*** exception is thrown when no valid linkage positions are given, nothing to do here in that case *** } } else { System.out.println("aglycon already present: " + dbTmpl.toString()); } } public static void writeAglyconTemplatesToDB() throws ResourcesDbException { AglyconTemplateContainer container = new AglyconTemplateContainer(); Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); for (String tmplName : container.getTemplateNameList(GlycanNamescheme.GLYCOCT)) { AglyconTemplate aglTmpl = container.getAglyconTemplateByName(GlycanNamescheme.GLYCOCT, tmplName); System.out.println("write aglycon template " + aglTmpl.getName()); writeOrUpdateSingleAglyconTemplateToDB(aglTmpl, session); } session.getTransaction().commit(); } // ***************************************************************************** // *** Representations: ******************************************************** // ***************************************************************************** public static ResidueRepresentation getMonosaccharideRepresentation(int repId) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); ResidueRepresentation dbRep = null; try { dbRep = (ResidueRepresentation) session .createQuery("from MonosaccharideRepresentation where id=" + repId).uniqueResult(); } catch (Exception e) { tx.rollback(); } return dbRep; } public static ResidueRepresentation getMonosaccharideRepresentation(int monoId, String formatStr, String typeStr) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); ResidueRepresentation dbRep = null; try { dbRep = (ResidueRepresentation) session .createQuery("from MonosaccharideRepresentation where monosaccharide_id=" + monoId + " and representation_format='" + formatStr + "' and representation_type='" + typeStr + "'") .uniqueResult(); } catch (Exception e) { tx.rollback(); } return dbRep; } public static void updateMonosaccharideRepresentations(Monosaccharide ms) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { if (ms != null) { System.out.println("check monosaccharide " + ms.toString() + "\n"); ms.updateRepresentations(); System.out.println(" updated representations..."); if (ms.getRepresentations() != null) { System.out.println(" representations: " + ms.getRepresentations().size()); for (ResidueRepresentation monoRep : ms.getRepresentations()) { System.out.println(" save or update rep. " + monoRep.toString()); session.saveOrUpdate("MonosaccharideRepresentation", monoRep); } } else { System.out.println(" getRepresentations() is null"); } } } catch (Exception e) { System.err.println("Exception: " + e); tx.rollback(); } tx.commit(); } public static void updateMonosaccharideRepresentations(int msId) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { Monosaccharide ms = HibernateAccess.getMonosaccharideFromDB(msId); if (ms != null) { updateMonosaccharideRepresentations(ms); /*System.out.println("check monosaccharide " + ms.toString() + "\n"); ms.updateRepresentations(); System.out.println(" updated representations..."); if(ms.getRepresentations() != null) { System.out.println(" representations: " + ms.getRepresentations().size()); for(ResidueRepresentation monoRep : ms.getRepresentations()) { System.out.println(" save or update rep. " + monoRep.toString()); session.saveOrUpdate("MonosaccharideRepresentation", monoRep); } } else { System.out.println(" getRepresentations() is null"); }*/ } } catch (Exception e) { System.err.println("Exception: " + e); tx.rollback(); } //tx.commit(); } public static void updateMonosaccharideRepresentations(int firstId, int lastId) { for (int i = firstId; i <= lastId; i++) { HibernateAccess.updateMonosaccharideRepresentations(i); } } // ***************************************************************************** // *** Linking Positions: ****************************************************** // ***************************************************************************** public static void updateMonosaccharideLinkingPositions(Monosaccharide ms) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { if (ms != null) { System.out.println("check monosaccharide " + ms.toString() + "\n"); if (ms.getPossibleLinkingPositions().size() == 0) { ms.setPossibleLinkingPositions(MonosaccharideDataBuilder.buildPossibleLinkagePositions(ms)); } for (MonosaccharideLinkingPosition linkpos : ms.getPossibleLinkingPositions()) { System.out.println(" save or update linkpos. " + linkpos.toString()); session.saveOrUpdate(linkpos); } } } catch (Exception e) { System.err.println("Exception: " + e); tx.rollback(); } tx.commit(); } public static void updateMonosaccharideLinkingPositions(int msId) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); Transaction tx = session.beginTransaction(); try { Monosaccharide ms = HibernateAccess.getMonosaccharideFromDB(msId); if (ms != null) { updateMonosaccharideLinkingPositions(ms); } } catch (Exception e) { System.err.println("Exception: " + e); tx.rollback(); } //tx.commit(); } public static void updateMonosaccharideLinkingPositions(int firstId, int lastId) { for (int i = firstId; i <= lastId; i++) { HibernateAccess.updateMonosaccharideLinkingPositions(i); } } // ***************************************************************************** // *** General Queries: ******************************************************** // ***************************************************************************** /** * Query the database by an HQL string and get results as a list. * @param hqlStr * @return a list of objects resulting from the query */ public static List<?> getObjectList(String hqlStr) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); Query q = session.createQuery(hqlStr); List<?> resultList = null; if (q != null) { resultList = q.list(); } return resultList; } public static List<?> getObjectList(DetachedCriteria queryCriteria) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); List<?> resultList = queryCriteria.getExecutableCriteria(session).list(); return resultList; } // ***************************************************************************** // *** Other methods: ********************************************************** // ***************************************************************************** public static void writeTemplateDataToDB(TemplateContainer container) throws ResourcesDbException { HibernateAccess.writeElementsToDB(); HibernateAccess.writeSubstituentTemplatesToDB(container.getSubstituentTemplateContainer()); HibernateAccess.writeAglyconTemplatesToDB(); } }