Uses of Class
org.hibernate.MappingException

Packages that use MappingException
org.hibernate This package defines the central Hibernate APIs. 
org.hibernate.cfg This package defines APIs for configuring Hibernate, and classes for building the Hibernate configuration-time metamodel. 
org.hibernate.cfg.annotations   
org.hibernate.dialect This package abstracts the SQL dialect of the underlying database. 
org.hibernate.ejb   
org.hibernate.engine.internal   
org.hibernate.engine.query.spi   
org.hibernate.engine.spi   
org.hibernate.hql.internal   
org.hibernate.hql.internal.ast An ANTLR-based parser for Hibernate Query Language. 
org.hibernate.hql.internal.classic This package contains the Hibernate 2.x query parser which is being end-of-lifed. 
org.hibernate.hql.spi   
org.hibernate.id This package contains internal implementation classes for the main API interfaces. 
org.hibernate.id.enhanced   
org.hibernate.internal An internal package containing mostly implementations of central Hibernate APIs. 
org.hibernate.internal.util Internal utility classes. 
org.hibernate.loader This package defines functionality for processing JDBC result sets and returning complex graphs of persistent objects. 
org.hibernate.loader.collection This package defines collection initializers 
org.hibernate.loader.criteria This package defines the criteria query compiler and loader 
org.hibernate.loader.entity This package defines entity loaders 
org.hibernate.mapping This package defines the Hibernate configuration-time metamodel. 
org.hibernate.metamodel.relational This package defines the metamodel of a relational database schema. 
org.hibernate.metamodel.source.internal   
org.hibernate.persister.collection This package abstracts the persistence mechanism for collections. 
org.hibernate.persister.entity This package abstracts persistence mechanisms for entities, and defines the Hibernate runtime metamodel. 
org.hibernate.property This package abstracts the notion of a "property" of an entity. 
org.hibernate.type A Hibernate Type is a strategy for mapping a Java property type to a JDBC type or types. 
 

Uses of MappingException in org.hibernate
 

Subclasses of MappingException in org.hibernate
 class AnnotationException
          Annotation related exception.
 class DuplicateMappingException
          Raised whenever a duplicate for a certain type occurs.
 class InvalidMappingException
          Thrown when a mapping is found to be invalid.
 class MappingNotFoundException
          Thrown when a resource for a mapping could not be found.
 class PropertyNotFoundException
          Indicates that an expected getter or setter method could not be found on a class.
 

Methods in org.hibernate that throw MappingException
 SQLQuery SQLQuery.addSynchronizedEntityClass(Class entityClass)
          Adds an entity for (a) auto-flush checking and (b) query result cache invalidation checking.
 SQLQuery SQLQuery.addSynchronizedEntityName(String entityName)
          Adds an entity name for (a) auto-flush checking and (b) query result cache invalidation checking.
 

Uses of MappingException in org.hibernate.cfg
 

Subclasses of MappingException in org.hibernate.cfg
 class NotYetImplementedException
          Mapping not yet implemented
 class RecoverableException
          Should neven be exposed to the client An exception that wrap an underlying exception whith the hope subsequent processing will recover from it.
 

Methods in org.hibernate.cfg that throw MappingException
 AnnotationConfiguration AnnotationConfiguration.addAnnotatedClass(Class annotatedClass)
          Deprecated. Read metadata from the annotations associated with this class.
 Configuration Configuration.addCacheableFile(File xmlFile)
          Add a cached mapping file.
 AnnotationConfiguration AnnotationConfiguration.addCacheableFile(File xmlFile)
          Deprecated.  
 Configuration Configuration.addCacheableFile(String xmlFile)
          Add a cacheable mapping file.
 AnnotationConfiguration AnnotationConfiguration.addCacheableFile(String xmlFile)
          Deprecated.  
 Configuration Configuration.addClass(Class persistentClass)
          Read a mapping as an application resource using the convention that a class named foo.bar.Foo is mapped by a file foo/bar/Foo.hbm.xml which can be resolved as a classpath resource.
 AnnotationConfiguration AnnotationConfiguration.addClass(Class persistentClass)
          Deprecated.  
 Configuration Configuration.addDirectory(File dir)
          Read all mapping documents from a directory tree.
 AnnotationConfiguration AnnotationConfiguration.addDirectory(File dir)
          Deprecated.  
 Configuration Configuration.addDocument(Document doc)
          Read mappings from a DOM Document
 AnnotationConfiguration AnnotationConfiguration.addDocument(Document doc)
          Deprecated.  
 Configuration Configuration.addFile(File xmlFile)
          Read mappings from a particular XML file
 AnnotationConfiguration AnnotationConfiguration.addFile(File xmlFile)
          Deprecated.  
 Configuration Configuration.addFile(String xmlFile)
          Read mappings from a particular XML file
 AnnotationConfiguration AnnotationConfiguration.addFile(String xmlFile)
          Deprecated.  
 Configuration Configuration.addInputStream(InputStream xmlInputStream)
          Read mappings from an InputStream.
 Configuration Configuration.addJar(File jar)
          Read all mappings from a jar file

Assumes that any file named *.hbm.xml is a mapping document.

 AnnotationConfiguration AnnotationConfiguration.addJar(File jar)
          Deprecated.  
 Configuration Configuration.addPackage(String packageName)
          Read package-level metadata.
 AnnotationConfiguration AnnotationConfiguration.addPackage(String packageName)
          Deprecated. Read package-level metadata.
 Configuration Configuration.addResource(String resourceName)
          Read mappings as a application resourceName (i.e.
 AnnotationConfiguration AnnotationConfiguration.addResource(String resourceName)
          Deprecated.  
 Configuration Configuration.addResource(String resourceName, ClassLoader classLoader)
          Read mappings as a application resource (i.e.
 AnnotationConfiguration AnnotationConfiguration.addResource(String resourceName, ClassLoader classLoader)
          Deprecated.  
 Configuration Configuration.addURL(URL url)
          Read mappings from a URL
 AnnotationConfiguration AnnotationConfiguration.addURL(URL url)
          Deprecated.  
 Configuration Configuration.addXML(String xml)
          Read mappings from a String
 AnnotationConfiguration AnnotationConfiguration.addXML(String xml)
          Deprecated.  
static void HbmBinder.bindAny(org.dom4j.Element node, Any any, boolean isNullable, Mappings mappings)
           
static void HbmBinder.bindArray(org.dom4j.Element node, Array array, String prefix, String path, Mappings mappings, Map inheritedMetas)
          Called for arrays and primitive arrays
static void HbmBinder.bindClass(org.dom4j.Element node, PersistentClass persistentClass, Mappings mappings, Map inheritedMetas)
           
static void AnnotationBinder.bindClass(org.hibernate.annotations.common.reflection.XClass clazzToProcess, Map<org.hibernate.annotations.common.reflection.XClass,InheritanceState> inheritanceStatePerClass, Mappings mappings)
          Bind a class having JSR175 annotations.
static void HbmBinder.bindCollection(org.dom4j.Element node, Collection collection, String className, String path, Mappings mappings, Map inheritedMetas)
          Called for all collections
static void HbmBinder.bindCollectionSecondPass(org.dom4j.Element node, Collection collection, Map persistentClasses, Mappings mappings, Map inheritedMetas)
          Called for all collections
static void HbmBinder.bindColumn(org.dom4j.Element node, Column column, boolean isNullable)
           
static void HbmBinder.bindColumns(org.dom4j.Element node, SimpleValue simpleValue, boolean isNullable, boolean autoColumn, String propertyPath, Mappings mappings)
           
static void HbmBinder.bindComponent(org.dom4j.Element node, Component component, String ownerClassName, String parentProperty, String path, boolean isNullable, boolean isEmbedded, Mappings mappings, Map inheritedMetas, boolean isIdentifierMapper)
           
static void HbmBinder.bindComposite(org.dom4j.Element node, Component component, String path, boolean isNullable, Mappings mappings, Map inheritedMetas)
           
static void HbmBinder.bindCompositeId(org.dom4j.Element node, Component component, PersistentClass persistentClass, String propertyName, Mappings mappings, Map inheritedMetas)
           
static void HbmBinder.bindIdentifierCollectionSecondPass(org.dom4j.Element node, IdentifierCollection collection, Map persistentClasses, Mappings mappings, Map inheritedMetas)
           
static void HbmBinder.bindJoinedSubclass(org.dom4j.Element node, JoinedSubclass joinedSubclass, Mappings mappings, Map inheritedMetas)
           
static void HbmBinder.bindListSecondPass(org.dom4j.Element node, List list, Map classes, Mappings mappings, Map inheritedMetas)
          Called for Lists, arrays, primitive arrays
static void HbmBinder.bindManyToOne(org.dom4j.Element node, ManyToOne manyToOne, String path, boolean isNullable, Mappings mappings)
           
static void HbmBinder.bindMapSecondPass(org.dom4j.Element node, Map map, Map classes, Mappings mappings, Map inheritedMetas)
          Called for Maps
static void HbmBinder.bindOneToMany(org.dom4j.Element node, OneToMany oneToMany, Mappings mappings)
           
static void HbmBinder.bindOneToOne(org.dom4j.Element node, OneToOne oneToOne, String path, boolean isNullable, Mappings mappings)
           
static void HbmBinder.bindProperty(org.dom4j.Element node, Property property, Mappings mappings, Map inheritedMetas)
           
static void HbmBinder.bindRoot(XmlDocument metadataXml, Mappings mappings, Map inheritedMetas, Set<String> entityNames)
          The main contract into the hbm.xml-based binder.
static void HbmBinder.bindRootClass(org.dom4j.Element node, RootClass rootClass, Mappings mappings, Map inheritedMetas)
          Responsible for performing the bind operation related to an <class/> mapping element.
static void HbmBinder.bindSimpleValue(org.dom4j.Element node, SimpleValue simpleValue, boolean isNullable, String path, Mappings mappings)
           
static void HbmBinder.bindSubclass(org.dom4j.Element node, Subclass subclass, Mappings mappings, Map inheritedMetas)
           
static void HbmBinder.bindUnionSubclass(org.dom4j.Element node, UnionSubclass unionSubclass, Mappings mappings, Map inheritedMetas)
           
protected static void HbmBinder.createClassProperties(org.dom4j.Element node, PersistentClass persistentClass, Mappings mappings, Map inheritedMetas)
           
protected static void HbmBinder.createClassProperties(org.dom4j.Element node, PersistentClass persistentClass, Mappings mappings, Map inheritedMetas, UniqueKey uniqueKey, boolean mutable, boolean nullable, boolean naturalId)
           
 void CreateKeySecondPass.doSecondPass(Map persistentClasses)
           
 void CopyIdentifierComponentSecondPass.doSecondPass(Map persistentClasses)
           
 void VerifyFetchProfileReferenceSecondPass.doSecondPass(Map persistentClasses)
           
 void ResultSetMappingSecondPass.doSecondPass(Map persistentClasses)
           
 void JoinedSubclassFkSecondPass.doSecondPass(Map persistentClasses)
           
 void ToOneFkSecondPass.doSecondPass(Map persistentClasses)
           
 void IndexOrUniqueKeySecondPass.doSecondPass(Map persistentClasses)
           
 void NamedSQLQuerySecondPass.doSecondPass(Map persistentClasses)
           
 void PkDrivenByDefaultMapsIdSecondPass.doSecondPass(Map persistentClasses)
           
 void SecondaryTableSecondPass.doSecondPass(Map persistentClasses)
           
 void SetSimpleValueTypeSecondPass.doSecondPass(Map persistentClasses)
           
 void CollectionSecondPass.doSecondPass(Map persistentClasses)
           
 void OneToOneSecondPass.doSecondPass(Map persistentClasses)
           
 void SecondPass.doSecondPass(Map persistentClasses)
           
 org.hibernate.annotations.common.reflection.XClass PropertyPreloadedData.getClassOrElement()
           
 org.hibernate.annotations.common.reflection.XClass PropertyData.getClassOrElement()
          Returns the returned class itself or the element type if an array
 org.hibernate.annotations.common.reflection.XClass WrappedInferredData.getClassOrElement()
           
 org.hibernate.annotations.common.reflection.XClass PropertyInferredData.getClassOrElement()
           
 String PropertyPreloadedData.getClassOrElementName()
           
 String PropertyData.getClassOrElementName()
          Returns the returned class name itself or the element type if an array
 String WrappedInferredData.getClassOrElementName()
           
 String PropertyInferredData.getClassOrElementName()
           
 AccessType PropertyPreloadedData.getDefaultAccess()
           
 AccessType PropertyInferredData.getDefaultAccess()
           
 String Mappings.getLogicalColumnName(String physicalName, Table table)
          Find the logical column name against whcih the given physical column name was bound within the given table.
 String Configuration.MappingsImpl.getLogicalColumnName(String physicalName, Table table)
           
 String Mappings.getLogicalTableName(Table table)
          Get the logical table name mapped for the given physical table.
 String Configuration.MappingsImpl.getLogicalTableName(Table table)
           
 String Mappings.getPhysicalColumnName(String logicalName, Table table)
          Find the physical column name for the given logical column name within the given table.
 String Configuration.MappingsImpl.getPhysicalColumnName(String logicalName, Table table)
           
 org.hibernate.annotations.common.reflection.XClass PropertyPreloadedData.getPropertyClass()
           
 org.hibernate.annotations.common.reflection.XClass PropertyData.getPropertyClass()
          Return the class itself
 org.hibernate.annotations.common.reflection.XClass WrappedInferredData.getPropertyClass()
           
 org.hibernate.annotations.common.reflection.XClass PropertyInferredData.getPropertyClass()
           
 String PropertyPreloadedData.getPropertyName()
           
 String PropertyData.getPropertyName()
           
 String WrappedInferredData.getPropertyName()
           
 String PropertyInferredData.getPropertyName()
           
static String HbmBinder.getTypeFromXML(org.dom4j.Element node)
           
 String PropertyPreloadedData.getTypeName()
           
 String PropertyData.getTypeName()
          Returns the returned class name itself
 String WrappedInferredData.getTypeName()
           
 String PropertyInferredData.getTypeName()
           
abstract  void CollectionSecondPass.secondPass(Map persistentClasses, Map inheritedMetas)
           
protected  void Configuration.secondPassCompile()
           
protected  void Configuration.secondPassCompileForeignKeys(Table table, Set<ForeignKey> done)
           
 void Configuration.setCacheConcurrencyStrategy(String entityName, String concurrencyStrategy, String region, boolean cacheLazyProperty)
           
 AnnotationConfiguration AnnotationConfiguration.setCollectionCacheConcurrencyStrategy(String collectionRole, String concurrencyStrategy)
          Deprecated.  
 

Uses of MappingException in org.hibernate.cfg.annotations
 

Methods in org.hibernate.cfg.annotations that throw MappingException
protected  void CollectionBinder.bindManyToManySecondPass(Collection collValue, Map persistentClasses, Ejb3JoinColumn[] joinColumns, Ejb3JoinColumn[] inverseJoinColumns, Ejb3Column[] elementColumns, boolean isEmbedded, org.hibernate.annotations.common.reflection.XClass collType, boolean ignoreNotFound, boolean unique, boolean cascadeDeleteEnabled, TableBinder associationTableBinder, org.hibernate.annotations.common.reflection.XProperty property, PropertyHolder parentPropertyHolder, String hqlOrderBy, Mappings mappings)
           
 void ResultsetMappingSecondPass.doSecondPass(Map persistentClasses)
           
 

Uses of MappingException in org.hibernate.dialect
 

Methods in org.hibernate.dialect that throw MappingException
 String TypeNames.get(int typecode)
          get default type name for specified type
 String TypeNames.get(int typeCode, long size, int precision, int scale)
          get type name for specified type and size
protected  String Dialect.getCreateSequenceString(String sequenceName)
          Typically dialects which support sequences can create a sequence with a single command.
protected  String Dialect.getCreateSequenceString(String sequenceName, int initialValue, int incrementSize)
          Overloaded form of Dialect.getCreateSequenceString(String), additionally taking the initial value and increment size to be applied to the sequence definition.
 String[] Dialect.getCreateSequenceStrings(String sequenceName)
          Deprecated. Use Dialect.getCreateSequenceString(String, int, int) instead
 String[] Dialect.getCreateSequenceStrings(String sequenceName, int initialValue, int incrementSize)
          An optional multi-line form for databases which Dialect.supportsPooledSequences().
protected  String Dialect.getDropSequenceString(String sequenceName)
          Typically dialects which support sequences can drop a sequence with a single command.
 String[] Dialect.getDropSequenceStrings(String sequenceName)
          The multiline script used to drop a sequence.
protected  String Dialect.getIdentityColumnString()
          The syntax used during DDL to define a column as being an IDENTITY.
protected  String CUBRIDDialect.getIdentityColumnString()
           
 String Cache71Dialect.getIdentityColumnString()
           
 String Dialect.getIdentityColumnString(int type)
          The syntax used during DDL to define a column as being an IDENTITY of a particular type.
 String InformixDialect.getIdentityColumnString(int type)
           
protected  String Dialect.getIdentitySelectString()
          Get the select command to use to retrieve the last generated IDENTITY value.
 String Dialect.getIdentitySelectString(String table, String column, int type)
          Get the select command to use to retrieve the last generated IDENTITY value for a particular table
 String InformixDialect.getIdentitySelectString(String table, String column, int type)
           
 String CUBRIDDialect.getIdentitySelectString(String table, String column, int type)
           
 String Dialect.getSelectSequenceNextValString(String sequenceName)
          Generate the select expression fragment that will retrieve the next value of a sequence as part of another (typically DML) statement.
 String Dialect.getSequenceNextValString(String sequenceName)
          Generate the appropriate select statement to to retrieve the next value of a sequence.
 

Uses of MappingException in org.hibernate.ejb
 

Methods in org.hibernate.ejb that throw MappingException
 Ejb3Configuration Ejb3Configuration.addAnnotatedClass(Class persistentClass)
          Deprecated.  
 Ejb3Configuration Ejb3Configuration.addClass(Class persistentClass)
          Deprecated.  
 Ejb3Configuration Ejb3Configuration.addFile(File xmlFile)
          Deprecated.  
 Ejb3Configuration Ejb3Configuration.addFile(String xmlFile)
          Deprecated.  
 Ejb3Configuration Ejb3Configuration.addInputStream(InputStream xmlInputStream)
          Deprecated.  
 Ejb3Configuration Ejb3Configuration.addPackage(String packageName)
          Deprecated.  
 Ejb3Configuration Ejb3Configuration.addResource(String path)
          Deprecated.  
 Ejb3Configuration Ejb3Configuration.addResource(String path, ClassLoader classLoader)
          Deprecated.  
 

Uses of MappingException in org.hibernate.engine.internal
 

Methods in org.hibernate.engine.internal that throw MappingException
 JoinSequence JoinSequence.addJoin(AssociationType associationType, String alias, JoinType joinType, String[] referencingKey)
           
 Object StatefulPersistenceContext.getCollectionOwner(Serializable key, CollectionPersister collectionPersister)
          Get the entity that owns this persistent collection
 boolean StatefulPersistenceContext.reassociateIfUninitializedProxy(Object value)
          Takes the given object and, if it represents a proxy, reassociates it with this event source.
 void StatefulPersistenceContext.reassociateProxy(Object value, Serializable id)
          If a deleted entity instance is re-saved, and it has a proxy, we need to reset the identifier of the proxy
 JoinFragment JoinSequence.toJoinFragment()
           
 JoinFragment JoinSequence.toJoinFragment(Map enabledFilters, boolean includeExtraJoins)
           
 JoinFragment JoinSequence.toJoinFragment(Map enabledFilters, boolean includeExtraJoins, String withClauseFragment, String withClauseJoinAlias)
           
 

Uses of MappingException in org.hibernate.engine.query.spi
 

Methods in org.hibernate.engine.query.spi that throw MappingException
 FilterQueryPlan QueryPlanCache.getFilterQueryPlan(String filterString, String collectionRole, boolean shallow, Map enabledFilters)
           
 HQLQueryPlan QueryPlanCache.getHQLQueryPlan(String queryString, boolean shallow, Map enabledFilters)
           
 

Uses of MappingException in org.hibernate.engine.spi
 

Methods in org.hibernate.engine.spi that throw MappingException
 Object PersistenceContext.getCollectionOwner(Serializable key, CollectionPersister collectionPersister)
          Get the entity that owns this persistent collection
 CollectionPersister SessionFactoryImplementor.getCollectionPersister(String role)
          Get the persister object for a collection role.
 EntityPersister SessionFactoryImplementor.getEntityPersister(String entityName)
          Get the persister for the named entity
 String Mapping.getIdentifierPropertyName(String className)
           
 Type Mapping.getIdentifierType(String className)
           
 String[] SessionFactoryImplementor.getImplementors(String className)
          Get the names of all persistent classes that implement/extend the given interface/class
 Type Mapping.getReferencedPropertyType(String className, String propertyName)
           
 Boolean VersionValue.isUnsaved(Object version)
           
 boolean PersistenceContext.reassociateIfUninitializedProxy(Object value)
          Takes the given object and, if it represents a proxy, reassociates it with this event source.
 void PersistenceContext.reassociateProxy(Object value, Serializable id)
          If a deleted entity instance is re-saved, and it has a proxy, we need to reset the identifier of the proxy
 

Constructors in org.hibernate.engine.spi that throw MappingException
CollectionEntry(PersistentCollection collection, SessionFactoryImplementor factory)
          For initialized detached collections
 

Uses of MappingException in org.hibernate.hql.internal
 

Methods in org.hibernate.hql.internal that throw MappingException
static String[] QuerySplitter.concreteQueries(String query, SessionFactoryImplementor factory)
          Handle Hibernate "implicit" polymorphism, by translating the query string into several "concrete" queries against mapped classes.
static String[][] NameGenerator.generateColumnNames(Type[] types, SessionFactoryImplementor f)
           
 

Uses of MappingException in org.hibernate.hql.internal.ast
 

Methods in org.hibernate.hql.internal.ast that throw MappingException
 void QueryTranslatorImpl.compile(Map replacements, boolean shallow)
          Compile a "normal" query.
 void QueryTranslatorImpl.compile(String collectionRole, Map replacements, boolean shallow)
          Compile a filter.
 

Uses of MappingException in org.hibernate.hql.internal.classic
 

Methods in org.hibernate.hql.internal.classic that throw MappingException
 void QueryTranslatorImpl.compile(Map replacements, boolean scalar)
          Compile a "normal" query.
 void QueryTranslatorImpl.compile(String collectionRole, Map replacements, boolean scalar)
          Compile a filter.
 

Uses of MappingException in org.hibernate.hql.spi
 

Methods in org.hibernate.hql.spi that throw MappingException
 void QueryTranslator.compile(Map replacements, boolean shallow)
          Compile a "normal" query.
 void FilterTranslator.compile(String collectionRole, Map replacements, boolean shallow)
          Compile a filter.
 

Uses of MappingException in org.hibernate.id
 

Methods in org.hibernate.id that throw MappingException
 void MultipleHiLoPerTableGenerator.configure(Type type, Properties params, Dialect dialect)
           
 void IncrementGenerator.configure(Type type, Properties params, Dialect dialect)
           
 void SequenceHiLoGenerator.configure(Type type, Properties params, Dialect d)
           
 void SelectGenerator.configure(Type type, Properties params, Dialect d)
           
 void Configurable.configure(Type type, Properties params, Dialect d)
          Configure this instance, given the value of parameters specified by the user as <param> elements.
 void UUIDGenerator.configure(Type type, Properties params, Dialect d)
           
 void Assigned.configure(Type type, Properties params, Dialect d)
           
 void SequenceIdentityGenerator.configure(Type type, Properties params, Dialect dialect)
           
 void SequenceGenerator.configure(Type type, Properties params, Dialect dialect)
           
 

Uses of MappingException in org.hibernate.id.enhanced
 

Methods in org.hibernate.id.enhanced that throw MappingException
 void TableGenerator.configure(Type type, Properties params, Dialect dialect)
           
 void SequenceStyleGenerator.configure(Type type, Properties params, Dialect dialect)
           
 

Uses of MappingException in org.hibernate.internal
 

Methods in org.hibernate.internal that throw MappingException
 CollectionPersister SessionFactoryImpl.getCollectionPersister(String role)
           
 EntityPersister SessionFactoryImpl.getEntityPersister(String entityName)
           
 String SessionFactoryImpl.getIdentifierPropertyName(String className)
           
 Type SessionFactoryImpl.getIdentifierType(String className)
           
 String[] SessionFactoryImpl.getImplementors(String className)
          Given the name of an entity class, determine all the class and interface names by which it can be referenced in an HQL query.
 Query SessionImpl.getNamedQuery(String queryName)
           
 Query AbstractSessionImpl.getNamedQuery(String queryName)
           
 Query AbstractSessionImpl.getNamedSQLQuery(String queryName)
           
 Type SessionFactoryImpl.getReferencedPropertyType(String className, String propertyName)
           
 

Constructors in org.hibernate.internal that throw MappingException
AbstractScrollableResults(ResultSet rs, PreparedStatement ps, SessionImplementor sess, Loader loader, QueryParameters queryParameters, Type[] types, HolderInstantiator holderInstantiator)
           
FetchingScrollableResultsImpl(ResultSet rs, PreparedStatement ps, SessionImplementor sess, Loader loader, QueryParameters queryParameters, Type[] types, HolderInstantiator holderInstantiator)
           
ScrollableResultsImpl(ResultSet rs, PreparedStatement ps, SessionImplementor sess, Loader loader, QueryParameters queryParameters, Type[] types, HolderInstantiator holderInstantiator)
           
 

Uses of MappingException in org.hibernate.internal.util
 

Methods in org.hibernate.internal.util that throw MappingException
static Getter ReflectHelper.getGetter(Class theClass, String name)
          Directly retrieve the Getter reference via the BasicPropertyAccessor.
static Class ReflectHelper.reflectedPropertyClass(Class clazz, String name)
          Attempt to resolve the specified property type through reflection.
static Class ReflectHelper.reflectedPropertyClass(String className, String name)
          Attempt to resolve the specified property type through reflection.
 

Uses of MappingException in org.hibernate.loader
 

Methods in org.hibernate.loader that throw MappingException
 void OuterJoinableAssociation.addJoins(JoinFragment outerjoin)
           
 void OuterJoinableAssociation.addManyToManyJoin(JoinFragment outerjoin, QueryableCollection collection)
           
protected static int JoinWalker.countCollectionPersisters(List associations)
          Count the number of instances of Joinable which are actually also instances of PersistentCollection which are being fetched by outer join
protected static int JoinWalker.countEntityPersisters(List associations)
          Count the number of instances of Joinable which are actually also instances of Loadable, or are one-to-many associations
protected  JoinType JoinWalker.getJoinType(AssociationType associationType, FetchMode config, PropertyPath path, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth, CascadeStyle cascadeStyle)
          Determine the appropriate associationType of join (if any) to use to fetch the given association.
protected  JoinType JoinWalker.getJoinType(OuterJoinLoadable persister, PropertyPath path, int propertyNumber, AssociationType associationType, FetchMode metadataFetchMode, CascadeStyle metadataCascadeStyle, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth)
          Determine the appropriate type of join (if any) to use to fetch the given association.
protected  String AbstractEntityJoinWalker.getWhereFragment()
           
protected  void AbstractEntityJoinWalker.initAll(String whereString, String orderByString, LockOptions lockOptions)
           
protected  void AbstractEntityJoinWalker.initAll(String whereString, String orderByString, LockOptions lockOptions, JoinWalker.AssociationInitCallback callback)
           
protected  void JoinWalker.initPersisters(List associations, LockMode lockMode)
           
protected  void JoinWalker.initPersisters(List associations, LockOptions lockOptions)
           
protected  void JoinWalker.initPersisters(List associations, LockOptions lockOptions, JoinWalker.AssociationInitCallback callback)
           
protected  void AbstractEntityJoinWalker.initProjection(String projectionString, String whereString, String orderByString, String groupByString, LockOptions lockOptions)
           
protected  boolean JoinWalker.isJoinedFetchEnabledInMapping(FetchMode config, AssociationType type)
          Does the mapping, and Hibernate default semantics, specify that this association should be fetched by outer joining
protected  JoinFragment JoinWalker.mergeOuterJoins(List associations)
          Generate a sequence of LEFT OUTER JOIN clauses for the given associations.
protected static String JoinWalker.orderBy(List associations)
          Get the order by string required for collection fetching
protected  String JoinWalker.selectString(List associations)
          Generate a select list of columns containing all properties of the entity classes
 void OuterJoinableAssociation.validateJoin(String path)
           
protected  void JoinWalker.walkCollectionTree(QueryableCollection persister, String alias)
          For a collection role, return a list of associations to be fetched by outerjoin
protected  void JoinWalker.walkEntityTree(OuterJoinLoadable persister, String alias)
          Walk the association tree for an entity, adding associations which should be join fetched to the JoinWalker.associations inst var.
 

Constructors in org.hibernate.loader that throw MappingException
OuterJoinableAssociation(PropertyPath propertyPath, AssociationType joinableType, String lhsAlias, String[] lhsColumns, String rhsAlias, JoinType joinType, String withClause, boolean hasRestriction, SessionFactoryImplementor factory, Map enabledFilters)
           
 

Uses of MappingException in org.hibernate.loader.collection
 

Methods in org.hibernate.loader.collection that throw MappingException
static CollectionInitializer BatchingCollectionInitializer.createBatchingCollectionInitializer(QueryableCollection persister, int maxBatchSize, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
static CollectionInitializer BatchingCollectionInitializer.createBatchingOneToManyInitializer(QueryableCollection persister, int maxBatchSize, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
protected  JoinType BasicCollectionJoinWalker.getJoinType(OuterJoinLoadable persister, PropertyPath path, int propertyNumber, AssociationType associationType, FetchMode metadataFetchMode, CascadeStyle metadataCascadeStyle, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth)
           
 

Constructors in org.hibernate.loader.collection that throw MappingException
BasicCollectionJoinWalker(QueryableCollection collectionPersister, int batchSize, String subquery, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
BasicCollectionLoader(QueryableCollection collectionPersister, int batchSize, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
BasicCollectionLoader(QueryableCollection collectionPersister, int batchSize, String subquery, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
BasicCollectionLoader(QueryableCollection collectionPersister, SessionFactoryImplementor session, LoadQueryInfluencers loadQueryInfluencers)
           
OneToManyJoinWalker(QueryableCollection oneToManyPersister, int batchSize, String subquery, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
OneToManyLoader(QueryableCollection oneToManyPersister, int batchSize, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
OneToManyLoader(QueryableCollection oneToManyPersister, int batchSize, String subquery, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
OneToManyLoader(QueryableCollection oneToManyPersister, SessionFactoryImplementor session, LoadQueryInfluencers loadQueryInfluencers)
           
SubselectCollectionLoader(QueryableCollection persister, String subquery, Collection entityKeys, QueryParameters queryParameters, Map namedParameterLocMap, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
SubselectOneToManyLoader(QueryableCollection persister, String subquery, Collection entityKeys, QueryParameters queryParameters, Map namedParameterLocMap, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
 

Uses of MappingException in org.hibernate.loader.criteria
 

Methods in org.hibernate.loader.criteria that throw MappingException
protected  JoinType CriteriaJoinWalker.getJoinType(AssociationType associationType, FetchMode config, PropertyPath path, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth, CascadeStyle cascadeStyle)
           
protected  JoinType CriteriaJoinWalker.getJoinType(OuterJoinLoadable persister, PropertyPath path, int propertyNumber, AssociationType associationType, FetchMode metadataFetchMode, CascadeStyle metadataCascadeStyle, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth)
           
protected  String CriteriaJoinWalker.getWhereFragment()
          Use the discriminator, to narrow the select to instances of the queried subclass, also applying any filters.
 

Uses of MappingException in org.hibernate.loader.entity
 

Methods in org.hibernate.loader.entity that throw MappingException
static UniqueEntityLoader BatchingEntityLoader.createBatchingEntityLoader(OuterJoinLoadable persister, int maxBatchSize, LockMode lockMode, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
static UniqueEntityLoader BatchingEntityLoader.createBatchingEntityLoader(OuterJoinLoadable persister, int maxBatchSize, LockOptions lockOptions, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
protected  JoinType EntityJoinWalker.getJoinType(OuterJoinLoadable persister, PropertyPath path, int propertyNumber, AssociationType associationType, FetchMode metadataFetchMode, CascadeStyle metadataCascadeStyle, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth)
           
 

Constructors in org.hibernate.loader.entity that throw MappingException
CascadeEntityJoinWalker(OuterJoinLoadable persister, CascadingAction action, SessionFactoryImplementor factory)
           
CascadeEntityLoader(OuterJoinLoadable persister, CascadingAction action, SessionFactoryImplementor factory)
           
CollectionElementLoader(QueryableCollection collectionPersister, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
EntityJoinWalker(OuterJoinLoadable persister, String[] uniqueKey, int batchSize, LockMode lockMode, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
EntityJoinWalker(OuterJoinLoadable persister, String[] uniqueKey, int batchSize, LockOptions lockOptions, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
EntityLoader(OuterJoinLoadable persister, int batchSize, LockMode lockMode, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
EntityLoader(OuterJoinLoadable persister, int batchSize, LockOptions lockOptions, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
EntityLoader(OuterJoinLoadable persister, LockMode lockMode, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
EntityLoader(OuterJoinLoadable persister, LockOptions lockOptions, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
EntityLoader(OuterJoinLoadable persister, String[] uniqueKey, Type uniqueKeyType, int batchSize, LockMode lockMode, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
EntityLoader(OuterJoinLoadable persister, String[] uniqueKey, Type uniqueKeyType, int batchSize, LockOptions lockOptions, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
 

Uses of MappingException in org.hibernate.mapping
 

Methods in org.hibernate.mapping that throw MappingException
 void PersistentClass.addSubclass(Subclass subclass)
           
 void RootClass.addSubclass(Subclass subclass)
           
protected  void PersistentClass.checkColumnDuplication(Set distinctColumns, Iterator columns)
           
protected  void PersistentClass.checkPropertyColumnDuplication(Set distinctColumns, Iterator properties)
           
 void Collection.createAllKeys()
           
 void Map.createAllKeys()
           
 void Value.createForeignKey()
           
 void ManyToOne.createForeignKey()
           
 void SimpleValue.createForeignKey()
           
abstract  void ToOne.createForeignKey()
           
 void OneToOne.createForeignKey()
           
 IdentifierGenerator SimpleValue.createIdentifierGenerator(IdentifierGeneratorFactory identifierGeneratorFactory, Dialect dialect, String defaultCatalog, String defaultSchema, RootClass rootClass)
           
 IdentifierGenerator KeyValue.createIdentifierGenerator(IdentifierGeneratorFactory identifierGeneratorFactory, Dialect dialect, String defaultCatalog, String defaultSchema, RootClass rootClass)
           
 IdentifierGenerator Component.createIdentifierGenerator(IdentifierGeneratorFactory identifierGeneratorFactory, Dialect dialect, String defaultCatalog, String defaultSchema, RootClass rootClass)
           
 CascadeStyle Property.getCascadeStyle()
           
 Class Component.getComponentClass()
           
abstract  CollectionType Collection.getDefaultCollectionType()
           
 CollectionType List.getDefaultCollectionType()
           
 CollectionType Array.getDefaultCollectionType()
           
 Class Array.getElementClass()
           
 Getter Property.getGetter(Class clazz)
           
 Class PersistentClass.getMappedClass()
           
 Property PersistentClass.getProperty(String propertyName)
           
 Property Component.getProperty(String propertyName)
           
 PropertyAccessor Property.getPropertyAccessor(Class clazz)
           
 Property PersistentClass.getRecursiveProperty(String propertyPath)
           
 Property PersistentClass.getReferencedProperty(String propertyPath)
          Given a property path, locate the appropriate referenceable property reference.
 Setter Property.getSetter(Class clazz)
           
 int Column.getSqlTypeCode(Mapping mapping)
           
 Type Value.getType()
           
 Type ManyToOne.getType()
           
 Type Property.getType()
           
 Type Collection.getType()
           
 Type SimpleValue.getType()
           
abstract  Type ToOne.getType()
           
 Type OneToOne.getType()
           
 Type Component.getType()
           
 Type Any.getType()
           
 Type DependantValue.getType()
           
 boolean Value.isValid(Mapping mapping)
           
 boolean OneToMany.isValid(Mapping mapping)
           
 boolean Property.isValid(Mapping mapping)
           
 boolean Collection.isValid(Mapping mapping)
           
 boolean SimpleValue.isValid(Mapping mapping)
           
 boolean ToOne.isValid(Mapping mapping)
           
 void ForeignKey.setReferencedTable(Table referencedTable)
           
 void Value.setTypeUsingReflection(String className, String propertyName)
           
 void SimpleValue.setTypeUsingReflection(String className, String propertyName)
           
 void ToOne.setTypeUsingReflection(String className, String propertyName)
           
 void Component.setTypeUsingReflection(String className, String propertyName)
           
 void Any.setTypeUsingReflection(String className, String propertyName)
           
 void SingleTableSubclass.validate(Mapping mapping)
           
 void Collection.validate(Mapping mapping)
           
 void UnionSubclass.validate(Mapping mapping)
           
 void PersistentClass.validate(Mapping mapping)
           
 void IndexedCollection.validate(Mapping mapping)
           
 void IdentifierCollection.validate(Mapping mapping)
           
 void RootClass.validate(Mapping mapping)
           
 void Set.validate(Mapping mapping)
           
 void JoinedSubclass.validate(Mapping mapping)
           
 

Constructors in org.hibernate.mapping that throw MappingException
Component(Mappings mappings, Collection collection)
           
Component(Mappings mappings, Component component)
           
Component(Mappings mappings, Join join)
           
Component(Mappings mappings, PersistentClass owner)
           
OneToMany(Mappings mappings, PersistentClass owner)
           
OneToOne(Mappings mappings, Table table, PersistentClass owner)
           
 

Uses of MappingException in org.hibernate.metamodel.relational
 

Methods in org.hibernate.metamodel.relational that throw MappingException
 String[] Sequence.sqlCreateStrings(Dialect dialect)
           
 String[] Sequence.sqlDropStrings(Dialect dialect)
           
 

Uses of MappingException in org.hibernate.metamodel.source.internal
 

Methods in org.hibernate.metamodel.source.internal that throw MappingException
 String MetadataImpl.getIdentifierPropertyName(String entityName)
           
 Type MetadataImpl.getIdentifierType(String entityName)
           
 Type MetadataImpl.getReferencedPropertyType(String entityName, String propertyName)
           
 

Uses of MappingException in org.hibernate.persister.collection
 

Methods in org.hibernate.persister.collection that throw MappingException
protected abstract  CollectionInitializer AbstractCollectionPersister.createCollectionInitializer(LoadQueryInfluencers loadQueryInfluencers)
           
protected  CollectionInitializer OneToManyPersister.createCollectionInitializer(LoadQueryInfluencers loadQueryInfluencers)
          Create the OneToManyLoader
protected  CollectionInitializer BasicCollectionPersister.createCollectionInitializer(LoadQueryInfluencers loadQueryInfluencers)
          Create the CollectionLoader
protected  String AbstractCollectionPersister.filterFragment(String alias)
           
 String OneToManyPersister.filterFragment(String alias)
           
 String AbstractCollectionPersister.filterFragment(String alias, Map enabledFilters)
           
 String AbstractCollectionPersister.oneToManyFilterFragment(String alias)
           
 void AbstractCollectionPersister.postInstantiate()
           
 void CollectionPersister.postInstantiate()
           
 

Constructors in org.hibernate.persister.collection that throw MappingException
AbstractCollectionPersister(Collection collection, CollectionRegionAccessStrategy cacheAccessStrategy, Configuration cfg, SessionFactoryImplementor factory)
           
BasicCollectionPersister(Collection collection, CollectionRegionAccessStrategy cacheAccessStrategy, Configuration cfg, SessionFactoryImplementor factory)
           
CompositeElementPropertyMapping(String[] elementColumns, String[] elementColumnReaders, String[] elementColumnReaderTemplates, String[] elementFormulaTemplates, CompositeType compositeType, Mapping factory)
           
ElementPropertyMapping(String[] elementColumns, Type type)
           
OneToManyPersister(Collection collection, CollectionRegionAccessStrategy cacheAccessStrategy, Configuration cfg, SessionFactoryImplementor factory)
           
 

Uses of MappingException in org.hibernate.persister.entity
 

Methods in org.hibernate.persister.entity that throw MappingException
protected  UniqueEntityLoader AbstractEntityPersister.createEntityLoader(LockMode lockMode)
           
protected  UniqueEntityLoader AbstractEntityPersister.createEntityLoader(LockMode lockMode, LoadQueryInfluencers loadQueryInfluencers)
           
protected  UniqueEntityLoader AbstractEntityPersister.createEntityLoader(LockOptions lockOptions, LoadQueryInfluencers loadQueryInfluencers)
           
protected  void AbstractEntityPersister.createUniqueKeyLoaders()
           
 Size[] DiscriminatorType.defaultSizes(Mapping mapping)
           
 Size[] DiscriminatorType.dictatedSizes(Mapping mapping)
           
 String SingleTableEntityPersister.filterFragment(String alias)
           
protected abstract  String AbstractEntityPersister.filterFragment(String alias)
           
 String Joinable.filterFragment(String alias, Map enabledFilters)
          Get the where clause filter, given a query alias and considering enabled session filters
 String AbstractEntityPersister.filterFragment(String alias, Map enabledFilters)
           
 int DiscriminatorType.getColumnSpan(Mapping mapping)
           
 Type EntityPersister.getPropertyType(String propertyName)
          Get the type of a particular property by name.
 Type AbstractEntityPersister.getPropertyType(String propertyName)
           
protected  void AbstractPropertyMapping.initComponentPropertyPaths(String path, CompositeType type, String[] columns, String[] columnReaders, String[] columnReaderTemplates, String[] formulaTemplates, Mapping factory)
           
protected  void AbstractPropertyMapping.initIdentifierPropertyPaths(String path, EntityType etype, String[] columns, String[] columnReaders, String[] columnReaderTemplates, Mapping factory)
           
protected  void AbstractEntityPersister.initPropertyPaths(Mapping mapping)
           
protected  void AbstractPropertyMapping.initPropertyPaths(String path, Type type, String[] columns, String[] columnReaders, String[] columnReaderTemplates, String[] formulaTemplates, Mapping factory)
           
protected  void AbstractEntityPersister.initSubclassPropertyAliasesMap(EntityBinding model)
          Must be called by subclasses, at the end of their constructors
protected  void AbstractEntityPersister.initSubclassPropertyAliasesMap(PersistentClass model)
          Must be called by subclasses, at the end of their constructors
 String Joinable.oneToManyFilterFragment(String alias)
           
 String SingleTableEntityPersister.oneToManyFilterFragment(String alias)
           
 String AbstractEntityPersister.oneToManyFilterFragment(String alias)
           
protected  void AbstractEntityPersister.postConstruct(Mapping mapping)
           
 void EntityPersister.postInstantiate()
          Finish the initialization of this object.
 void AbstractEntityPersister.postInstantiate()
           
 int[] DiscriminatorType.sqlTypes(Mapping mapping)
           
 

Uses of MappingException in org.hibernate.property
 

Methods in org.hibernate.property that throw MappingException
static PropertyAccessor PropertyAccessorFactory.getDynamicMapPropertyAccessor()
           
static PropertyAccessor PropertyAccessorFactory.getPropertyAccessor(AttributeBinding property, EntityMode mode)
          Retrieves a PropertyAccessor instance based on the given property definition and entity mode.
static PropertyAccessor PropertyAccessorFactory.getPropertyAccessor(Class optionalClass, String type)
           
static PropertyAccessor PropertyAccessorFactory.getPropertyAccessor(Property property, EntityMode mode)
          Retrieves a PropertyAccessor instance based on the given property definition and entity mode.
static PropertyAccessor PropertyAccessorFactory.getPropertyAccessor(String type)
           
 

Uses of MappingException in org.hibernate.type
 

Methods in org.hibernate.type that throw MappingException
 Size[] CompositeCustomType.defaultSizes(Mapping mapping)
           
 Size[] MetaType.defaultSizes(Mapping mapping)
           
 Size[] Type.defaultSizes(Mapping mapping)
          Defines the column sizes to use according to this type if the user did not explicitly say (and if no Type.dictatedSizes(org.hibernate.engine.spi.Mapping) were given).
 Size[] ComponentType.defaultSizes(Mapping mapping)
           
 Size[] AbstractLobType.defaultSizes(Mapping mapping)
          Deprecated.  
 Size[] SpecialOneToOneType.defaultSizes(Mapping mapping)
           
 Size[] ManyToOneType.defaultSizes(Mapping mapping)
           
 Size[] OneToOneType.defaultSizes(Mapping mapping)
           
 Size[] CollectionType.defaultSizes(Mapping mapping)
           
 Size[] AnyType.defaultSizes(Mapping mapping)
           
 Size[] CustomType.defaultSizes(Mapping mapping)
           
 Size[] NullableType.defaultSizes(Mapping mapping)
          Deprecated.  
 Size[] AbstractStandardBasicType.defaultSizes(Mapping mapping)
           
 Size[] CompositeCustomType.dictatedSizes(Mapping mapping)
           
 Size[] MetaType.dictatedSizes(Mapping mapping)
           
 Size[] Type.dictatedSizes(Mapping mapping)
          Return the column sizes dictated by this type.
 Size[] ComponentType.dictatedSizes(Mapping mapping)
           
 Size[] AbstractLobType.dictatedSizes(Mapping mapping)
          Deprecated.  
 Size[] SpecialOneToOneType.dictatedSizes(Mapping mapping)
           
 Size[] ManyToOneType.dictatedSizes(Mapping mapping)
           
 Size[] OneToOneType.dictatedSizes(Mapping mapping)
           
 Size[] CollectionType.dictatedSizes(Mapping mapping)
           
 Size[] AnyType.dictatedSizes(Mapping mapping)
           
 Size[] CustomType.dictatedSizes(Mapping mapping)
           
 Size[] NullableType.dictatedSizes(Mapping mapping)
          Deprecated.  
 Size[] AbstractStandardBasicType.dictatedSizes(Mapping mapping)
           
 String AssociationType.getAssociatedEntityName(SessionFactoryImplementor factory)
          Get the entity name of the associated entity
 String CollectionType.getAssociatedEntityName(SessionFactoryImplementor factory)
           
 String AnyType.getAssociatedEntityName(SessionFactoryImplementor factory)
           
 Joinable AssociationType.getAssociatedJoinable(SessionFactoryImplementor factory)
          Get the "persister" for this association - a class or collection persister
 Joinable CollectionType.getAssociatedJoinable(SessionFactoryImplementor factory)
           
 Joinable EntityType.getAssociatedJoinable(SessionFactoryImplementor factory)
          Retrieves the Joinable defining the associated entity.
 int CompositeCustomType.getColumnSpan(Mapping mapping)
           
 int MetaType.getColumnSpan(Mapping mapping)
           
 int Type.getColumnSpan(Mapping mapping)
          How many columns are used to persist this type.
 int ComponentType.getColumnSpan(Mapping mapping)
           
 int AbstractLobType.getColumnSpan(Mapping mapping)
          Deprecated.  
 int SpecialOneToOneType.getColumnSpan(Mapping mapping)
           
 int ManyToOneType.getColumnSpan(Mapping mapping)
           
 int OneToOneType.getColumnSpan(Mapping session)
           
 int CollectionType.getColumnSpan(Mapping session)
           
 int AnyType.getColumnSpan(Mapping session)
           
 int AbstractStandardBasicType.getColumnSpan(Mapping mapping)
           
 Type CollectionType.getElementType(SessionFactoryImplementor factory)
          Get the Hibernate type of the collection elements
 String EntityType.getIdentifierOrUniqueKeyPropertyName(Mapping factory)
          The name of the property on the associated entity to which our FK refers
 Type EntityType.getIdentifierOrUniqueKeyType(Mapping factory)
          Determine the type of either (1) the identifier if we reference the associated entity's PK or (2) the unique key to which we refer (i.e.
 String AssociationType.getOnCondition(String alias, SessionFactoryImplementor factory, Map enabledFilters)
          Get the "filtering" SQL fragment that is applied in the SQL on clause, in addition to the usual join condition
 String CollectionType.getOnCondition(String alias, SessionFactoryImplementor factory, Map enabledFilters)
           
 String AnyType.getOnCondition(String alias, SessionFactoryImplementor factory, Map enabledFilters)
           
 String EntityType.getOnCondition(String alias, SessionFactoryImplementor factory, Map enabledFilters)
           
 Type TypeResolver.heuristicType(String typeName)
          See TypeResolver.heuristicType(String, Properties)
 Type TypeResolver.heuristicType(String typeName, Properties parameters)
          Uses heuristics to deduce the proper Type given a string naming the type or Java class.
 int[] CompositeCustomType.sqlTypes(Mapping mapping)
           
 int[] SerializableToBlobType.sqlTypes(Mapping mapping)
           
 int[] MetaType.sqlTypes(Mapping mapping)
           
 int[] Type.sqlTypes(Mapping mapping)
          Return the JDBC types codes (per Types) for the columns mapped by this type.
 int[] ComponentType.sqlTypes(Mapping mapping)
           
 int[] SpecialOneToOneType.sqlTypes(Mapping mapping)
           
 int[] ManyToOneType.sqlTypes(Mapping mapping)
           
 int[] OneToOneType.sqlTypes(Mapping session)
           
 int[] CollectionType.sqlTypes(Mapping session)
           
 int[] AnyType.sqlTypes(Mapping mapping)
           
 int[] AbstractStandardBasicType.sqlTypes(Mapping mapping)
           
 

Constructors in org.hibernate.type that throw MappingException
CustomType(UserType userType)
           
CustomType(UserType userType, String[] registrationKeys)
           
 



Copyright © 2001-2012 Red Hat, Inc. All Rights Reserved.