Java tutorial
/******************************************************************************* * Copyright 2015 * Ubiquitous Knowledge Processing (UKP) Lab * Technische Universitt Darmstadt * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ package de.tudarmstadt.ukp.lmf.api; import java.io.FileNotFoundException; import java.sql.SQLException; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Properties; import org.hibernate.Criteria; import org.hibernate.SQLQuery; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; import org.hibernate.criterion.DetachedCriteria; import org.hibernate.criterion.Property; import org.hibernate.criterion.Restrictions; import org.hibernate.service.ServiceRegistryBuilder; import de.tudarmstadt.ukp.lmf.hibernate.HibernateConnect; import de.tudarmstadt.ukp.lmf.model.core.LexicalEntry; import de.tudarmstadt.ukp.lmf.model.core.LexicalResource; import de.tudarmstadt.ukp.lmf.model.core.Lexicon; import de.tudarmstadt.ukp.lmf.model.core.Sense; import de.tudarmstadt.ukp.lmf.model.enums.ELanguageIdentifier; import de.tudarmstadt.ukp.lmf.model.enums.EPartOfSpeech; import de.tudarmstadt.ukp.lmf.model.meta.SemanticLabel; import de.tudarmstadt.ukp.lmf.model.multilingual.PredicateArgumentAxis; import de.tudarmstadt.ukp.lmf.model.multilingual.SenseAxis; import de.tudarmstadt.ukp.lmf.model.semantics.MonolingualExternalRef; import de.tudarmstadt.ukp.lmf.model.semantics.PredicativeRepresentation; import de.tudarmstadt.ukp.lmf.model.semantics.SemanticArgument; import de.tudarmstadt.ukp.lmf.model.semantics.SemanticPredicate; import de.tudarmstadt.ukp.lmf.model.semantics.SynSemArgMap; import de.tudarmstadt.ukp.lmf.model.semantics.Synset; import de.tudarmstadt.ukp.lmf.transform.DBConfig; /** * Uby class represents the main entrance point to the UBY API. It holds methods for searching of * different UBY-LMF elements in a database containing a {@link LexicalResource}. * <p> * * Methods of this class return fully initialized UBY-LMF class instances. For performance reasons, * you also may want to use {@link UbyQuickAPI}. * * @author Judith Eckle-Kohler * @author Michael Matuschek * @author Christian M. Meyer * @author Tri-Duc Nghiem * @author Silvana Hartmann * @author Zijad Maksuti */ public class Uby { protected DBConfig dbConfig; protected Configuration cfg; protected static SessionFactory sessionFactory; protected Session session; /** * Constructor for a {@link Uby} instance used for searching of different elements in a database * containing UBY-LMF {@link LexicalResource}. * * The connection to the database is specified using a {@link DBConfig} instance. * * @param dbConfig * configuration of the database containing UBY-LMF lexical resource. * @throws UbyInvalidArgumentException * if the specified dbConfig is null */ public Uby(DBConfig dbConfig) throws IllegalArgumentException { if (dbConfig == null) { throw new IllegalArgumentException("database configuration is null"); } // if it is not yet instantiated, create a new SessionFactory if (sessionFactory == null) { this.dbConfig = dbConfig; cfg = HibernateConnect.getConfiguration(dbConfig); ServiceRegistryBuilder serviceRegistryBuilder = new ServiceRegistryBuilder() .applySettings(cfg.getProperties()); sessionFactory = cfg.buildSessionFactory(serviceRegistryBuilder.buildServiceRegistry()); } // A SessionFactory provide a thread-safe implementation // Now each thread can instantiate its Uby object and the SessionFactory // opens a new Session for him this.session = sessionFactory.openSession(); } public Uby(DBConfig dbConfig, Properties extraHibernate) throws IllegalArgumentException { if (dbConfig == null) { throw new IllegalArgumentException("database configuration is null"); } // if it is not yet instantiated, create a new SessionFactory if (sessionFactory == null) { this.dbConfig = dbConfig; cfg = HibernateConnect.getConfiguration(dbConfig, extraHibernate); ServiceRegistryBuilder serviceRegistryBuilder = new ServiceRegistryBuilder() .applySettings(cfg.getProperties()); sessionFactory = cfg.buildSessionFactory(serviceRegistryBuilder.buildServiceRegistry()); } // A SessionFactory provide a thread-safe implementation // Now each thread can instantiate its Uby object and the SessionFactory // opens a new Session for him this.session = sessionFactory.openSession(); } /** * Using this empty constructor, you have to set Value for parameter dbConfig afterwards. * * @deprecated marked for deletion, use {@link #Uby(DBConfig)} instead. */ @Deprecated public Uby() { //do nothing } /** * Setting the configuration for the Uby database * * @param dbconfig * Database configuration of the Uby database * @deprecated marked for deletion */ @Deprecated public void setDbConfig(DBConfig dbconfig) throws FileNotFoundException { this.dbConfig = dbconfig; cfg = HibernateConnect.getConfiguration(dbConfig); sessionFactory = cfg.buildSessionFactory(); openSession(); } /** * Returns the {@link DBConfig} instance used by this {@link Uby} instance to access the UBY-LMF * database. * * @return Database configuration of the Uby database */ public DBConfig getDbConfig() { return dbConfig; } /** * @deprecated this method is marked for deletion */ @Deprecated public SessionFactory getSessionFactory() { return sessionFactory; } /** * Opens hibernate database session * * @deprecated marked for deletion */ @Deprecated public void openSession() { session = sessionFactory.openSession(); } /** * Closes Hibernate database session * * @deprecated marked for deletion */ @Deprecated public void closeSession() { session.close(); } /** * Returns the Hibernate {@link Session} of this {@link Uby} instance. * * @return the session created by this Uby instance */ public Session getSession() { return session; } /** * Fetches a {@link LexicalResource} from the UBY-Database by its name. * * @param name * the name of the lexical resource to be fetched * * @return the lexical resource with the specified name or null if the database accessed by this * {@link Uby} instance does not contain a lexical resource with the specified name * * @see LexicalResource#getName() */ public LexicalResource getLexicalResource(String name) { LexicalResource lexicalResource = (LexicalResource) session.get(LexicalResource.class, name); return lexicalResource; } /** * Fetches the one UBY-LMF {@link LexicalResource} instance named "Uby" from the database * accessed by this {@link Uby} instance. * * This should work if the database has been created correctly and is the recommended way to * obtain the UBY-LMF lexical resource. * * @return a lexical resource named "Uby", contained in the accessed database, or null if the * database does not contain the lexical resource with the name "Uby" */ public LexicalResource getLexicalResource() { return this.getLexicalResource("Uby"); } /** * Fetches a {@link List} of names of all {@link Lexicon} instances contained in the database * accessed by this {@link Uby} instance. * * @return a list of names of all lexicons contained in the accessed UBY-LMF database or an * empty list if the database does not contain any lexicons * * @see Lexicon#getName() */ public List<String> getLexiconNames() { Criteria criteria = session.createCriteria(Lexicon.class); criteria = criteria.setProjection(Property.forName("name")); @SuppressWarnings("unchecked") List<String> result = criteria.list(); if (result == null) { result = new ArrayList<String>(0); } return result; } /** * Fetches a {@link Lexicon} with the specified name from the database accessed by this * {@link Uby} instance. * * @param lexiconName * the name of the Lexicon to be fetched. Possible values of this argument are: * <ul> * <li>"FrameNet"</li> * <li>"OmegaWikide"</li> * <li>"OmegaWikien"</li> * <li>"Wikipedia"</li> * <li>"WikipediaDE"</li> * <li>"WiktionaryEN"</li> * <li>"WiktionaryDE"</li> * <li>"VerbNet"</li> * <li>"WordNet"</li> * </ul> * @return the lexicon with the specified name * @throws UbyInvalidArgumentException * if no lexicon with the given name is found * @see Lexicon#getName() */ public Lexicon getLexiconByName(String lexiconName) throws IllegalArgumentException { Criteria criteria = session.createCriteria(Lexicon.class); criteria = criteria.add(Restrictions.eq("name", lexiconName)); Lexicon result = (Lexicon) criteria.uniqueResult(); if (result == null) { throw new IllegalArgumentException("Database does not contain a lexicon called " + lexiconName); } return result; } /** * Fetches a {@link Lexicon} with the specified name from the database accessed by this * {@link Uby} instance. * * @param lexiconId * the id of the Lexicon to be fetched. * @return the lexicon with the specified lexiconId * @throws UbyInvalidArgumentException * if no lexicon with the given name is found * @see Lexicon#getId() */ public Lexicon getLexiconById(String lexiconId) throws IllegalArgumentException { Criteria criteria = session.createCriteria(Lexicon.class); criteria = criteria.add(Restrictions.eq("id", lexiconId)); Lexicon result = (Lexicon) criteria.uniqueResult(); if (result == null) { throw new IllegalArgumentException("Database does not contain a lexicon with id " + lexiconId); } return result; } /** * Fetches a {@link List} of {@link LexicalEntry} instances which written representation is the * specified word. * * Optionally lexical entries can be filtered by part-of-speech and a {@link Lexicon}. * * @param word * the written representation of the lexical entries to be fetched * @param lexicon * If not null, filters lexical entries by the specified lexicon. Note that the * Lexicon instance has to be obtained beforehand. * @return A list of lexical entries matching the specified criteria. If no lexical entry * matches the specified criteria, this method returns an empty list. * @see LexicalEntry#getLemma() */ public List<LexicalEntry> getLexicalEntries(String word, Lexicon lexicon) { return getLexicalEntries(word, null, lexicon); } /** * Fetches a {@link List} of {@link LexicalEntry} instances which written representation is the * specified word. * * Optionally lexical entries can be filtered by part-of-speech and a {@link Lexicon}. * * @param word * the written representation of the lexical entries to be fetched * @param pos * the part-of-speech of the lexical entries to be fetched. Set to null in order to * skip part-of-speech filtering and fetch all lexical entries matching other * constraints, regardless of their part-of-speech. * @param lexicon * If not null, filters lexical entries by the specified lexicon. Note that the * Lexicon instance has to be obtained beforehand. * @return A list of lexical entries matching the specified criteria. If no lexical entry * matches the specified criteria, this method returns an empty list. * * @see EPartOfSpeech * @see LexicalEntry#getLemma() */ public List<LexicalEntry> getLexicalEntries(String word, EPartOfSpeech pos, Lexicon lexicon) { Criteria criteria = session.createCriteria(LexicalEntry.class); if (pos != null) { criteria = criteria.add(Restrictions.eq("partOfSpeech", pos)); } if (lexicon != null) { criteria = criteria.add(Restrictions.eq("lexicon", lexicon)); } criteria = criteria.createCriteria("lemma").createCriteria("formRepresentations") .add(Restrictions.eq("writtenForm", word)); @SuppressWarnings("unchecked") List<LexicalEntry> result = criteria.list(); if (result == null) { result = new ArrayList<LexicalEntry>(0); } return result; } /** * Returns an {@link Iterator} over {@link LexicalEntry} instances which written representation * is the specified word. * * Optionally lexical entries can be filtered by part-of-speech and a {@link Lexicon}. * * @param lexicon * If not null, filters lexical entries by the specified lexicon. Note that the * Lexicon instance has to be obtained beforehand. * @return An Iterator over lexical entries matching the specified criteria * * @see EPartOfSpeech * @see LexicalEntry#getLemma() */ public Iterator<LexicalEntry> getLexicalEntryIterator(Lexicon lexicon) { return getLexicalEntryIterator(null, lexicon); } /** * Returns an {@link Iterator} over {@link LexicalEntry} instances which written representation * is the specified word. * * Optionally lexical entries can be filtered by part-of-speech and a {@link Lexicon}. * * @param pos * the part-of-speech of the lexical entries to be iterated over. Set to null in * order to skip part-of-speech filtering and create an iterator over all lexical * entries matching other constraints, regardless of their part-of-speech. * @param lexicon * If not null, filters lexical entries by the specified lexicon. Note that the * Lexicon instance has to be obtained beforehand. * @return An Iterator over lexical entries matching the specified criteria * * @see EPartOfSpeech * @see LexicalEntry#getLemma() */ public Iterator<LexicalEntry> getLexicalEntryIterator(EPartOfSpeech pos, Lexicon lexicon) { DetachedCriteria criteria = DetachedCriteria.forClass(LexicalEntry.class); if (pos != null) { criteria = criteria.add(Restrictions.eq("partOfSpeech", pos)); } if (lexicon != null) { criteria = criteria.add(Restrictions.eq("lexicon", lexicon)); } CriteriaIterator<LexicalEntry> lexEntryIterator = new CriteriaIterator<LexicalEntry>(criteria, sessionFactory, 500); return lexEntryIterator; } /** * Returns an {@link Iterator} over {@link SenseAxis} instances * * @return An iterator over sense axes matching the specified criteria */ public Iterator<SenseAxis> getSenseAxisIterator() { DetachedCriteria criteria = DetachedCriteria.forClass(SenseAxis.class); CriteriaIterator<SenseAxis> senseAxisIterator = new CriteriaIterator<SenseAxis>(criteria, sessionFactory, 500); return senseAxisIterator; } /** * This methods allows retrieving a {@link LexicalEntry} instance by its exact identifier. * * @param lexicalEntryId * the unique identifier of the LexicalEntry which should be returned * @return the LexicalEntry with the consumed lexicalEntryId * @throws UbyInvalidArgumentException * if a LexicalEntry with this identifier does not exist */ public LexicalEntry getLexicalEntryById(String lexicalEntryId) throws IllegalArgumentException { Criteria criteria = session.createCriteria(LexicalEntry.class).add(Restrictions.eq("id", lexicalEntryId)); LexicalEntry ret = null; if (criteria.list() != null && criteria.list().size() > 0) { ret = (LexicalEntry) criteria.list().get(0); } if (ret == null) { throw new IllegalArgumentException("LexicalEntry with the ID " + lexicalEntryId + " does not exist"); } return ret; } /** * Retrieves a {@link List} of {@link LexicalEntry} instances with lemmas that start with the * parameter lemma. E.g. lemma = "leave" -> LexicalEntry with lemma = "leave no stone unturned" * is retrieved (among others) * * Optionally lexical entries can be filtered by part-of-speech and a {@link Lexicon}. * * @param lemma * the lemma the lexical entries has to start with * @param pos * the part-of-speech of the lexical entries to be fetched. Set to null in order to * skip part-of-speech filtering and fetch all lexical entries matching other * constraints, regardless of their part-of-speech. * @param lexicon * If not null, filters lexical entries by the specified lexicon. Note that the * Lexicon instance has to be obtained beforehand. * @return A list of lexical entries matching the specified criteria. If no lexical entry * matches the specified criteria, this method returns an empty list. * @see EPartOfSpeech * @see LexicalEntry#getLemma() */ public List<LexicalEntry> getLexicalEntriesByLemmaPrefix(String lemma, EPartOfSpeech pos, Lexicon lexicon) { Criteria criteria = session.createCriteria(LexicalEntry.class); if (pos != null) { criteria = criteria.add(Restrictions.eq("partOfSpeech", pos)); } if (lexicon != null) { criteria = criteria.add(Restrictions.eq("lexicon", lexicon)); } criteria = criteria.createCriteria("lemma").createCriteria("formRepresentations") .add(Restrictions.like("writtenForm", lemma + "%")); @SuppressWarnings("unchecked") List<LexicalEntry> result = criteria.list(); if (result == null) { result = new ArrayList<LexicalEntry>(0); } return result; } /** * Returns a {@link List} of all {@link Lexicon} instances contained in the database accessed by * this {@link Uby} instance. * * @return a list of all lexicons contained in the database or an empty list if the database * contains no lexicons */ public List<Lexicon> getLexicons() { Criteria criteria = session.createCriteria(Lexicon.class); @SuppressWarnings("unchecked") List<Lexicon> result = criteria.list(); if (result == null) { result = new ArrayList<Lexicon>(0); } return result; } /** * This method fetches all {@link Lexicon} instances from the accessed database by the specified * language identifier. * * @param lang * the language identifier of the lexicons to be fetched * * @return A {@link List} of all lexicons with the specified language identifier.<br> * This method returns an empty list if the specified identifier is null or the database * accessed by this {@link Uby} instance does not contain any lexicon with the given * identifier. * * @see ELanguageIdentifier * @see Lexicon#getLanguageIdentifier() */ //TODO LanguageIdentifier is now a String public List<Lexicon> getLexiconsByLanguage(String lang) { Criteria criteria = session.createCriteria(Lexicon.class); criteria = criteria.add(Restrictions.eq("languageIdentifier", lang)); @SuppressWarnings("unchecked") List<Lexicon> result = criteria.list(); if (result == null) { result = new ArrayList<Lexicon>(0); } return result; } /** * Returns {@link Iterator} over all {@link Sense} instances contained in the database accessed * by this {@link Uby} instance.<br> * Optionally, the returned senses can be filtered by {@link Lexicon}. * * @param lexicon * If not null, senses are filtered by the given lexicon * * @return an iterator over all senses in the accessed database filtered by the given lexicon if * not null */ public Iterator<Sense> getSenseIterator(Lexicon lexicon) { DetachedCriteria criteria = DetachedCriteria.forClass(Sense.class); if (lexicon != null) { criteria = criteria.createCriteria("lexicalEntry").add(Restrictions.eq("lexicon", lexicon)); } CriteriaIterator<Sense> senseIterator = new CriteriaIterator<Sense>(criteria, sessionFactory, 500); return senseIterator; } /** * Returns {@link Iterator} over all {@link Synset} instances contained in the database accessed * by this {@link Uby} instance.<br> * Optionally, the returned synsets can be filtered by {@link Lexicon}. * * @param lexicon * If not null, synsets are filtered by the given lexicon * * @return an iterator over all synsets in the accessed database filtered by the given lexicon * if not null */ public Iterator<Synset> getSynsetIterator(Lexicon lexicon) { DetachedCriteria criteria = DetachedCriteria.forClass(Synset.class); if (lexicon != null) { criteria = criteria.add(Restrictions.eq("lexicon", lexicon)); } CriteriaIterator<Synset> synsetIterator = new CriteriaIterator<Synset>(criteria, sessionFactory, 500); return synsetIterator; } /** * Returns the {@link Sense} instance contained in the database accessed by this {@link Uby} * instance. The returned senses are filtered by the given name of the external system and * external reference. * * @param externalSys * the {@link String} representing the name of external system such as: * FrameNet_1.5_eng_lexicalUnit VerbNet_3.1_eng_sense * OmegaWiki_<version>_<language>_synTrans WordNet_3.0_eng_senseKey * Wiktionary_<version>_<language>_sense Wikipedia_<version>_<language>_articleTitle * GermaNet_7.0_deu_lexicalUnit * @param externalRef * the reference string from external system, such as: * <ul> * <li>WordNet: "[POS: noun] house%1:15:00::" - POS and sense key Returns a list of * one sense</li> * <li>VerbNet: "retire_withdraw-82-3" Several UBY senses can have the same original * sense ID</li> * <li>FrameNet: "2676" - lexical unit ID</li> * <li>Wiktionary: "16:0:1" - sense key</li> * <li>Wikipedia: "House" - article title</li> * <li>OW: "303002" - OW SynTrans Id</li> * </ul> * @return a {@link List} of all senses filtered by the given arguments or an empty list if if * one of the given arguments is null or the accessed database does not contain any * senses matching both constraints */ public List<Sense> getSensesByOriginalReference(String externalSys, String externalRef) { Criteria criteria = session.createCriteria(Sense.class); criteria = criteria.createCriteria("monolingualExternalRefs").add(Restrictions.and( Restrictions.eq("externalSystem", externalSys), Restrictions.eq("externalReference", externalRef))); @SuppressWarnings("unchecked") List<Sense> result = criteria.list(); if (result == null) { result = new ArrayList<Sense>(0); } return result; } /** * Returns the {@link Synset} instance contained in the database accessed by this {@link Uby} * instance. * * @param externalSys * the {@link String} representing the name of external system such as: * OmegaWiki_2010-01-03_eng_definedMeaning WordNet_3.0_eng_synsetOffset * GermaNet_7.0_deu_synset * * @param externalRef * the Synset ID used in the external system, * * @returns the {@link Synset} specified by the given arguments */ public Synset getSynsetByOriginalReference(String externalSys, String externalRef) { Criteria criteria = session.createCriteria(Synset.class); criteria = criteria.createCriteria("monolingualExternalRefs").add(Restrictions.and( Restrictions.eq("externalSystem", externalSys), Restrictions.eq("externalReference", externalRef))); return (Synset) criteria.uniqueResult(); } /** * Returns the {@link Sense} instance contained in the database accessed by this {@link Uby} * instance. The returned senses are filtered by the given name of the external system, external * reference and lexicon. * * @return a {@link List} of all senses filtered by the given arguments or an empty list if one * of the given arguments is null or the accessed database does not contain any senses * matching both constraints. **/ public List<Sense> getSensesByOriginalReference(String externalSys, String externalRef, Lexicon lexicon) { Criteria criteria = session.createCriteria(Sense.class); criteria = criteria.createCriteria("monolingualExternalRefs").add(Restrictions.and( Restrictions.eq("externalSystem", externalSys), Restrictions.eq("externalReference", externalRef))); @SuppressWarnings("unchecked") List<Sense> result = criteria.list(); if (result == null) { result = new ArrayList<Sense>(0); } List<Sense> temp = new ArrayList<Sense>(result); for (Sense s : temp) { if (!s.getLexicalEntry().getLexicon().getName().equals(lexicon.getName())) { result.remove(s); } } return result; } /** * Returns a {@link List} of all {@link SenseAxis} instances contained in the database accessed * by this {@link Uby} instance. * * @return a list of all sense axes in the accessed database or an empty list if the accessed * database does not contain any sense axes */ public List<SenseAxis> getSenseAxes() { Criteria criteria = session.createCriteria(SenseAxis.class); @SuppressWarnings("unchecked") List<SenseAxis> result = criteria.list(); if (result == null) { result = new ArrayList<SenseAxis>(0); } return result; } /** * This method finds all {@link SenseAxis} instances which id contains the specified * {@link String} in the database accessed by this {@link Uby} instance. * * @param senseAxisId * string contained in the identifiers of the sense axes to be returned * * @return the {@link List} of all sense axes which id contains the specified string.<br> * This method returns an empty list if no sense axis contains the specified string in * its id or the specified string is null. * * @see #getSenseAxes() * @see #getSenseAxesBySense(Sense) * @see #getSenseAxesByIdPattern(String) */ public List<SenseAxis> getSenseAxesByIdPattern(String senseAxisId) { Criteria criteria = session.createCriteria(SenseAxis.class); criteria = criteria.add(Restrictions.sqlRestriction("senseAxisId like '%" + senseAxisId + "%'")); @SuppressWarnings("unchecked") List<SenseAxis> result = criteria.list(); if (result == null) { result = new ArrayList<SenseAxis>(0); } return result; } /** * This method retrieves all {@link SenseAxis} which bind the specified {@link Sense}. * * @param sense * all returned sense axes should bind this sense * * @return all sense axes (sense alignments) that contain the consumed sense.<br> * This method returns an empty list if the accessed UBY-LMF database does not contain * any alignments of the specified sense, or the specified sense is null. */ public List<SenseAxis> getSenseAxesBySense(Sense sense) { if (sense != null && sense.getId() != null && !sense.getId().equals("")) { Criteria criteria = session.createCriteria(SenseAxis.class); criteria = criteria .add(Restrictions.or(Restrictions.eq("senseOne", sense), Restrictions.eq("senseTwo", sense))); @SuppressWarnings("unchecked") List<SenseAxis> result = criteria.list(); return result; } else { return new ArrayList<SenseAxis>(0); } } /** * Consumes two {@link Sense} instances and returns true if and only if the consumed instances * are aligned by a {@link SenseAxis} instance. * * @param sense1 * the sense to be checked for alignment with sense2 * @param sense2 * the sense to be checked for alignment with sense1 * @return true if and only if sense1 has an alignment to sense2 by a sense axis instance so * that sense1 is the first sense of a sense axis and sense2 the second.<br> * This method returns false if one of the consumed senses is null. * @see SenseAxis#getSenseOne() * @see SenseAxis#getSenseTwo() */ public boolean hasSensesAxis(Sense sense1, Sense sense2) { boolean ret = false; if (sense1 != null && sense2 != null && sense1.getId() != null && sense1.getId().length() > 0 && sense2.getId() != null && sense2.getId().length() > 0) { String sql = "Select senseOneId, senseTwoId from SenseAxis where " + "(senseOneId='" + sense1.getId() + "' and senseTwoId='" + sense2.getId() + "')" + "or(senseOneId='" + sense2.getId() + "' and senseTwoId='" + sense1.getId() + "')"; List<?> query = session.createSQLQuery(sql).list(); if (query.size() > 0) { ret = true; } } return ret; } /** * Returns a {@link List} of all {@link Sense} instances which unique identifier contains the * consumed {@link String}. * * @param idPattern * the pattern which identifiers of the returned senses must contain * @return the list of all senses which unique identifier contains the idPattern * <p> * If none of the senses contained in the UBY-Database accessed by this {@link Uby} * instance contains the consumed pattern this method returns an empty list. */ public List<Sense> getSensesbyIdPattern(String idPattern) { Criteria criteria = session.createCriteria(Sense.class); criteria = criteria.add(Restrictions.sqlRestriction("senseId like '%" + idPattern + "%'")); @SuppressWarnings("unchecked") List<Sense> result = criteria.list(); return result; } /** * This methods allows retrieving a {@link Sense} instance by its exact identifier. * * @param senseId * the unique identifier of the sense which should be returned * @return the sense with the consumed senseId * @throws UbyInvalidArgumentException * if a sense with this identifier does not exist */ public Sense getSenseById(String senseId) throws IllegalArgumentException { Criteria criteria = session.createCriteria(Sense.class).add(Restrictions.eq("id", senseId)); List<?> result = criteria.list(); if (result.size() < 0) { throw new IllegalArgumentException("Sense with this ID does not exist"); } return (Sense) result.get(0); } /** * This methods allows retrieving a {@link Synset} instance by its exact identifier. * * @param synsetId * the unique identifier of the synset which should be returned * @return the synset with the consumed senseId * @throws UbyInvalidArgumentException * if a synset with this identifier does not exist */ public Synset getSynsetById(String synsetId) throws IllegalArgumentException { Criteria criteria = session.createCriteria(Synset.class).add(Restrictions.eq("id", synsetId)); List<?> result = criteria.list(); if (result.size() < 0) { throw new IllegalArgumentException("Synset with the ID " + synsetId + " does not exist"); } return (Synset) result.get(0); } /** * @deprecated use {@link #wordNetSenses(String, String)} or * {@link #wordNetSense(String, String)} instead */ @SuppressWarnings("unchecked") @Deprecated public List<Sense> getWNSensebyExtRef(String offset, String POS) throws ClassNotFoundException, SQLException { String refId = "[POS: noun] "; if (POS.equals("adjective")) { refId = refId.replaceAll("noun", "adjective"); } else if (POS.equals("adverb")) { refId = refId.replaceAll("noun", "adverb"); } else if (POS.equals("verb")) { refId = refId.replaceAll("noun", "verb"); } refId = refId + offset; /* * This direct query avoids the joining huge table done by using normal hibernate, while we just need the ID */ String sqlQueryString = "SELECT synsetId FROM MonolingualExternalRef WHERE externalReference = '" + refId.trim() + "'"; SQLQuery query = session.createSQLQuery(sqlQueryString); @SuppressWarnings("rawtypes") Iterator iter = query.list().iterator(); String ss_id = ""; while (iter.hasNext()) { ss_id = (String) iter.next(); } Criteria criteria = session.createCriteria(Sense.class); criteria = criteria.add(Restrictions.sqlRestriction("synsetId='" + ss_id.trim() + "'")); return criteria.list(); } /** * @param POS * : POS value=comment<br> * a = adj;<br> * n = noun;<br> * r = adv<br> * v = verb<br> * @param SynsetOffset * : offset value of Synset; * @return list of senses belong to the given synset * @Deprecated use {@link #wordNetSenses(String, String)} or * {@link #wordNetSense(String, String)} instead */ @Deprecated public List<Sense> getSensesByWNSynsetId(String POS, String SynsetOffset) throws ClassNotFoundException, SQLException { String refId = "[POS: noun] "; if (POS.equals("a")) { refId = refId.replaceAll("noun", "adjective"); } else if (POS.equals("r")) { refId = refId.replaceAll("noun", "adverb"); } else if (POS.equals("v")) { refId = refId.replaceAll("noun", "verb"); } refId = refId + SynsetOffset; Criteria criteria = session.createCriteria(Sense.class); criteria = criteria.createCriteria("monolingualExternalRefs") .add(Restrictions.sqlRestriction("externalReference='" + refId.trim() + "'")); @SuppressWarnings("unchecked") List<Sense> result = criteria.list(); return result; } /** * Consumes a synset identifier (in WordNet terminology) and returns a {@link List} of * {@link Sense} instances which are derived from the WordNets synset, specified by the consumed * identifier. * * @param wnSynsetId * string representation of the WordNets synset identifier i.e. "1740-n" * * @return a list of senses derived from the WordNets synset, specified by the consumed * identifier * <p> * This method returns an empty list if the database accessed by this {@link Uby} * instance does not contain senses derived from the specified WordNet synset. * * @deprecated use {@link #wordNetSense(String, String)} and * {@link #wordNetSense(String, String)} instead */ @Deprecated public List<Sense> getSensesByWNSynsetId(String wnSynsetId) { String[] temp = wnSynsetId.split("-"); String refId = "[POS: noun] "; if (temp[1].equals("a")) { refId = refId.replaceAll("noun", "adjective"); } else if (temp[1].equals("r")) { refId = refId.replaceAll("noun", "adverb"); } else if (temp[1].equals("v")) { refId = refId.replaceAll("noun", "verb"); } refId = refId + temp[0]; Criteria criteria = session.createCriteria(Sense.class); criteria = criteria.createCriteria("synset").createCriteria("monolingualExternalRefs") .add(Restrictions.sqlRestriction("externalReference='" + refId.trim() + "'")); @SuppressWarnings("unchecked") List<Sense> result = criteria.list(); return result; } /** * Consumes a synset offset (in WordNet terminology) and a part-of-speech. Returns a * {@link List} of all {@link Sense} instances which are derived from the WordNets synset, * identified by the consumed arguments. * * @param partOfSpeech * a string describing part of speech of the senses to be returned. * <p> * Valid values are: <list> * <li>"noun"</li> * <li>"verb"</li> * <li>"adverb"</li> * <li>"adjective"</li> </list> * * @param offset * string representation of the WordNets synset offset i.e. "14469014" * * @return senses derived from the WordNets synset, described by the consumed arguments * <p> * This method returns an empty list if the database accessed by this {@link Uby} * instance does not contain the specified sense. * * @throws UbyInvalidArgumentException * if the specified part of speech is not valid or one of consumed arguments is null * * @since 0.2.0 */ @Deprecated public List<Sense> wordNetSenses(String partOfSpeech, String offset) throws IllegalArgumentException { if (partOfSpeech == null) { throw new IllegalArgumentException("partOfSpeech is null"); } if (offset == null) { throw new IllegalArgumentException("offset is null"); } String refId = "[POS: noun] "; if (partOfSpeech.equals("adjective")) { refId = refId.replaceAll("noun", "adjective"); } else if (partOfSpeech.equals("adverb")) { refId = refId.replaceAll("noun", "adverb"); } else if (partOfSpeech.equals("verb")) { refId = refId.replaceAll("noun", "verb"); } else if (!partOfSpeech.equals("noun")) { throw new IllegalArgumentException("\"" + partOfSpeech + "\"" + " is not a valid part of speech. Only \"noun\", \"verb\", \"adverb\" or \"adjective\" are allowed"); } refId = refId + offset; /* * This direct query avoids the joining huge table done by using normal hibernate, while we just need the ID */ String sqlQueryString = "SELECT synsetId FROM MonolingualExternalRef WHERE externalReference = '" + refId.trim() + "'"; SQLQuery query = session.createSQLQuery(sqlQueryString); String ss_id = (String) query.uniqueResult(); if (ss_id == null) { return new ArrayList<Sense>(0); } Criteria criteria = session.createCriteria(Sense.class); criteria = criteria.add(Restrictions.sqlRestriction("synsetId='" + ss_id.trim() + "'")); @SuppressWarnings("unchecked") List<Sense> result = criteria.list(); return result; } /** * Consumes a sense key (in WordNet terminology) and a part-of-speech. Returns a {@link Sense} * instance which is derived from the WordNets sense, identified by the consumed arguments. * * @param partOfSpeech * a string describing part of speech of the sense to be returned. * <p> * Valid values are: <list> * <li>"noun"</li> * <li>"verb"</li> * <li>"adverb"</li> * <li>"adjective"</li> </list> * * @param senseKey * string representation of the WordNets identifier of a sense i.e. "enter%2:33:00::" * * @return UBY-LMF sense derived from the WordNets word, described by the consumed arguments * <p> * This method returns null if the database accessed by this {@link Uby} instance does * not contain the specified sense. * * @throws UbyInvalidArgumentException * if the specified part of speech is not valid or one of the consumed arguments is * null * * @since 0.2.0 */ @Deprecated public Sense wordNetSense(String partOfSpeech, String senseKey) throws IllegalArgumentException { if (partOfSpeech == null) { throw new IllegalArgumentException("partOfSpeech is null"); } if (senseKey == null) { throw new IllegalArgumentException("senseKey is null"); } String refId = "[POS: noun] "; if (partOfSpeech.equals("adjective")) { refId = refId.replaceAll("noun", "adjective"); } else if (partOfSpeech.equals("adverb")) { refId = refId.replaceAll("noun", "adverb"); } else if (partOfSpeech.equals("verb")) { refId = refId.replaceAll("noun", "verb"); } else if (!partOfSpeech.equals("noun")) { throw new IllegalArgumentException("\"" + partOfSpeech + "\"" + " is not a valid part of speech. Only \"noun\", \"verb\", \"adverb\" or \"adjective\" are allowed"); } refId = refId + senseKey; /* * This direct query avoids the joining huge table done by using normal hibernate, while we just need the ID */ String sqlQueryString = "SELECT senseId FROM MonolingualExternalRef WHERE externalReference = '" + refId.trim() + "'"; SQLQuery query = session.createSQLQuery(sqlQueryString); String ss_id = (String) query.uniqueResult(); if (ss_id == null) { return null; } Criteria criteria = session.createCriteria(Sense.class); criteria = criteria.add(Restrictions.sqlRestriction("senseId='" + ss_id.trim() + "'")); Sense result = (Sense) criteria.uniqueResult(); return result; } // OmegaWiki /** * Consumes an identifier of a SynTrans (in OmegaWiki terminology) and * returns a {@link List} of all {@link Sense} instances derived from the * specified SynTrans. * <br> * A SynTrans in OmegaWiki corresponds to a sense in WordNet. As OmegaWikis * senses are not ordered by frequency, the otherwise unused index field is * used to store the original SynTransId, hence making the additional join * with {@link MonolingualExternalRef} unnecessary. * * @param synTransId * a {@link String} representation of a unique identifier of * OmegaWikis SynTrans * @return list of all senses derived from specified OmegaWikis SynTrans. * <br> * This method returns an empty list if a SynTrans with specified * identifier does not exist or the database accessed by this * {@link Uby} instance does not contain a OmegaWiki {@link Lexicon}. */ @Deprecated public List<Sense> getSensesByOWSynTransId(String synTransId) { Criteria criteria = session.createCriteria(Sense.class); criteria = criteria.add(Restrictions.eq("index", Integer.parseInt(synTransId.trim()))); @SuppressWarnings("unchecked") List<Sense> result = criteria.list(); return result; } /** * Consumes a unique identifier of a {@link Sense} instance and returns a {@link List} of all * {@link SemanticLabel} instances associated to the specified sense. * * @param senseId * a unique identifier of the sense for which semantic labels should be returned * @return a list of all semantic labels of the specified sense or an empty list if a sense with * such identifier does not exist or the sense does not have any associated semantic * labels */ public List<SemanticLabel> getSemanticLabelsbySenseId(String senseId) { Criteria criteria = session.createCriteria(SemanticLabel.class); criteria = criteria.add(Restrictions.sqlRestriction("senseId='" + senseId + "'")); @SuppressWarnings("unchecked") List<SemanticLabel> result = criteria.list(); return result; } /** * Consumes a unique identifier of a {@link Sense} instance and returns a {@link List} of all * {@link SemanticLabel} instances associated to the specified sense. The returned semantic * labels are filtered by the specified type. * * * @param senseId * a unique identifier of the sense for which semantic labels should be returned * @param type * returned semantic labels must have this type * @return a list of all semantic labels of the specified sense filtered by the type or an empty * list if the database accessed by this {@link Uby} instance does not contain any * semantic labels matching the criteria */ public List<SemanticLabel> getSemanticLabelsbySenseIdbyType(String senseId, String type) { Criteria criteria = session.createCriteria(SemanticLabel.class); criteria = criteria.add(Restrictions.sqlRestriction("senseId='" + senseId + "' and type ='" + type + "'")); @SuppressWarnings("unchecked") List<SemanticLabel> result = criteria.list(); return result; } /** * Return the semantic predicate with the given Id * * @param predicateId * the id of the predicate * @return semantic predicate */ public SemanticPredicate getSemanticPredicateById(String predicateId) { Criteria criteria = session.createCriteria(SemanticPredicate.class); criteria = criteria.add(Restrictions.sqlRestriction("semanticPredicateId='" + predicateId + "'")); return (SemanticPredicate) criteria.uniqueResult(); } /** * Returns a {@link List} of all {@link SemanticPredicate} instances in the * database with the given label and filtered by {@link Lexicon}. * @param label * semantic predicate label * @param lexicon * all returned semantic predicates will belong to * the specified lexicon * @return list of semantic predicates which matches the criteria or an * empty list if none of the semantic predicates matches the * criteria */ public List<SemanticPredicate> getSemanticPredicatesByLabelAndLexicon(String label, Lexicon lexicon) { System.err.println(lexicon.getId()); Criteria criteria = session.createCriteria(SemanticPredicate.class); criteria = criteria .add(Restrictions.and(Restrictions.eq("label", label), Restrictions.eq("lexicon", lexicon))); @SuppressWarnings("unchecked") List<SemanticPredicate> result = criteria.list(); if (result == null) { result = new ArrayList<SemanticPredicate>(0); } return result; } /** * Returns a {@link List} of all {@link SemanticPredicate} instances in the * database accessed by this {@link Uby} instance, optionally filtered by * {@link Lexicon}. * * @param lexicon * if not null, all returned semantic predicates will belong to * the specified lexicon * @return list of semantic predicates which matches the criteria or an * empty list if none of the semantic predicates matches the * criteria */ public List<SemanticPredicate> getSemanticPredicates(Lexicon lexicon) { Criteria criteria = session.createCriteria(SemanticPredicate.class); if (lexicon != null) { String lexId = lexicon.getId(); criteria = criteria.add(Restrictions.sqlRestriction("lexiconId='" + lexId + "'")); } @SuppressWarnings("unchecked") List<SemanticPredicate> result = criteria.list(); return result; } /** * Return an {@link Iterator} over {@link SemanticPredicate} instances, * optionally filtered by a {@link Lexicon}. * * @param lexicon * if not null, the iterator will only be for semantic predicates * of the specified lexicon * * @return iterator over the semantic predicates in the specified lexicon.<br> * If the specified lexicon is null, this method returns an iterator * over all semantic predicates in the {@link LexicalResource}, * accessed by this {@link Uby} instance. */ public Iterator<SemanticPredicate> getSemanticPredicateIterator(Lexicon lexicon) { DetachedCriteria criteria = DetachedCriteria.forClass(SemanticPredicate.class); if (lexicon != null) { String lexId = lexicon.getId(); criteria = criteria.add(Restrictions.sqlRestriction("lexiconId='" + lexId + "'")); } CriteriaIterator<SemanticPredicate> predicateIterator = new CriteriaIterator<SemanticPredicate>(criteria, sessionFactory, 500); return predicateIterator; } /** * Returns the {@link SemanticArgument} instance with the specified unique identifier. * * @param argumentId * the unique identifier of the semantic argument to be returned * * @return semantic argument with the specified unique identifier, contained in the database * accessed by this {@link Uby} instance.<br> * If a semantic argument with the specified identifier does not exist, this method * return null. */ public SemanticArgument getSemanticArgumentById(String argumentId) { Criteria criteria = session.createCriteria(SemanticArgument.class); criteria = criteria.add(Restrictions.sqlRestriction("semanticArgumentId='" + argumentId + "'")); return (SemanticArgument) criteria.uniqueResult(); } /** * Returns a {@link List} of all {@link SemanticArgument} instances in the * database with the given label and {@link SemanticPredicate}. * @param label * semantic argument label * @param lexicon * all returned semantic arguments will belong to * the specified lexicon * @return list of semantic predicates which matches the criteria or an * empty list if none of the semantic predicates matches the * criteria */ public List<SemanticArgument> getSemanticArgumentsByLabelAndPredicate(String roleLabel, SemanticPredicate predicate) { Criteria criteria = session.createCriteria(SemanticArgument.class); System.err.println(" predicateid " + predicate.getId()); criteria = criteria.add(Restrictions.and(Restrictions.eq("predicate", predicate), Restrictions.eq("semanticRole", roleLabel))); @SuppressWarnings("unchecked") List<SemanticArgument> result = criteria.list(); if (result == null) { result = new ArrayList<SemanticArgument>(0); } return result; } /** * Returns all {@link SynSemArgMap} instances contained in the database accessed by this * {@link Uby} instance. * * @return a list of all mappings between syntactic and semantic arguments.<br> * If the database does not contain any mappings, this method returns an empty list. */ public List<SynSemArgMap> getSynSemArgMaps() { Criteria criteriaSynSem = session.createCriteria(SynSemArgMap.class); @SuppressWarnings("unchecked") List<SynSemArgMap> result = criteriaSynSem.list(); return result; } @Override protected void finalize() throws Throwable { //dbConfig = null; -- FindBugs: This finalizer nulls out fields. This is usually an error, as it does not aid garbage collection, and the object is going to be garbage collected anyway. session.close(); } /** * Returns a {@link List} of all {@link SemanticPredicate} instances in the * database that are associated with a {@link Sense} with the given senseId * @param senseId * UBY sense Id string * @return list of semantic predicates which matches the criteria or an empty list */ public List<SemanticPredicate> getSemanticPredicatesBySenseId(String senseId) { Criteria criteria = session.createCriteria(PredicativeRepresentation.class); criteria = criteria.add(Restrictions.sqlRestriction("senseId='" + senseId + "'")); @SuppressWarnings("unchecked") List<PredicativeRepresentation> representations = criteria.list(); List<SemanticPredicate> result = new ArrayList<>(); for (PredicativeRepresentation predicative : representations) { result.add(predicative.getPredicate()); } return result; } /** * Returns a {@link List} of all {@link Sense} instances in the * database that are associated with a {@link SemanticPredicate} with the given semanticPredicateId * @param semanticPredicateid * UBY semanticPredicateId string * @return list of senses which matches the criteria or an empty list */ public List<Sense> getSensesBySemanticPredicateId(String semanticPredicateId) { Criteria criteria = session.createCriteria(PredicativeRepresentation.class); criteria = criteria.add(Restrictions.sqlRestriction("predicate='" + semanticPredicateId + "'")); @SuppressWarnings("unchecked") List<PredicativeRepresentation> representations = criteria.list(); List<Sense> result = new ArrayList<>(); for (PredicativeRepresentation predicative : representations) { result.add(predicative.getSense()); } return result; } /** * Returns a {@link List} of all {@link PredicateArgumentAxis} instances contained in the database accessed * by this {@link Uby} instance. * * @return a list of all predicate-argument axes in the accessed database or an empty list if the accessed * database does not contain any sense axes */ public List<PredicateArgumentAxis> getPredicateArgumentAxes() { Criteria criteria = session.createCriteria(PredicateArgumentAxis.class); @SuppressWarnings("unchecked") List<PredicateArgumentAxis> result = criteria.list(); if (result == null) { result = new ArrayList<PredicateArgumentAxis>(0); } return result; } /** * This method finds all {@link PredicateArgumentAxis} instances whose id contains the specified * {@link String} in the database accessed by this {@link Uby} instance. * * @param senseAxisId * string contained in the identifiers of the predicate-argument axes to be returned * * @return the {@link List} of all predicate-argument axes whose id contains the specified string.<br> * This method returns an empty list if no axis contains the specified string in * its id or the specified string is null. * * @see #getPredicateArgumentAxes() * @see #getSenseAxesBySense(Sense) */ public List<PredicateArgumentAxis> getPredicateArgumentAxesByIdPattern(String axisId) { Criteria criteria = session.createCriteria(PredicateArgumentAxis.class); criteria = criteria.add(Restrictions.sqlRestriction("predicateArgumentAxisId like '%" + axisId + "%'")); @SuppressWarnings("unchecked") List<PredicateArgumentAxis> result = criteria.list(); if (result == null) { result = new ArrayList<PredicateArgumentAxis>(0); } return result; } /** * This method retrieves all {@link PredicateArgumentAxis} which bind the specified {@link SemanticPredicate}. * * @param predicate * all returned predicate-argument axes should bind this semantic predicate * * @return all predicate-argument axes that contain the consumed semantic predicate.<br> * This method returns an empty list if the accessed UBY-LMF database does not contain * any alignments of the specified semantic predicate, or the specified semantic predicate is null. */ public List<PredicateArgumentAxis> getPredicateArgumentAxesByPredicate(SemanticPredicate predicate) { if (predicate != null && predicate.getId() != null && !predicate.getId().equals("")) { Criteria criteria = session.createCriteria(PredicateArgumentAxis.class); criteria = criteria.add(Restrictions.or(Restrictions.eq("semanticPredicateOne", predicate), Restrictions.eq("semanticPredicateTwo", predicate))); @SuppressWarnings("unchecked") List<PredicateArgumentAxis> result = criteria.list(); return result; } else { return new ArrayList<PredicateArgumentAxis>(0); } } /** * Consumes two {@link SemanticPredicate} instances and returns true if and only if the consumed instances * are aligned by a {@link PredicateArgumentAxis} instance. * * @param pred1 * the semantic predicate to be checked for alignment with pred2 * @param pred2 * the semantic predicate to be checked for alignment with pred1 * @return true if and only if pred1 has an alignment to pred2 by a predicate-argument axis instance so * that pred1 is the first semantic predicate of an axis and pred2 the second.<br> * This method returns false if one of the consumed semantic predicates is null. * @see PredicateArgumentAxis#getSemanticPredicateOne() * @see PredicateArgumentAxis#getSemanticPredicateTwo() */ public boolean hasPredicateArgumentAxis(SemanticPredicate pred1, SemanticPredicate pred2) { boolean ret = false; if (pred1 != null && pred2 != null && pred1.getId() != null && pred1.getId().length() > 0 && pred2.getId() != null && pred2.getId().length() > 0) { String sql = "Select semanticPredicateOne, semanticPredicateTwo from PredicateArgumentAxis where " + "(semanticPredicateOne='" + pred1.getId() + "' and semanticPredicateTwo='" + pred2.getId() + "')" + "or(semanticPredicateOne='" + pred2.getId() + "' and semanticPredicateTwo='" + pred1.getId() + "')"; List<?> query = session.createSQLQuery(sql).list(); if (query.size() > 0) { ret = true; } } return ret; } }