## 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: This package contains classes that are "shared" by other packages, and implementations of some key algorithms.
org.hibernate.engine.query
org.hibernate.hql: This package defines the interface between Hibernate and the HQL query parser implementation (to allow switching between the 2.x and 3.0 HQL parsers).
org.hibernate.hql.ast: An ANTLR-based parser for Hibernate Query Language.
org.hibernate.hql.classic: This package contains the Hibernate 2.x query parser which is being end-of-lifed.
org.hibernate.id: This package contains internal implementation classes for the main API interfaces.
org.hibernate.id.enhanced
org.hibernate.impl: This package contains implementations of the central Hibernate APIs, especially the Hibernate session.
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.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.
org.hibernate.util: Utility classes.

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 perfoming 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` `VerifyFetchProfileReferenceSecondPass.doSecondPass(Map persistentClasses)`
`void` `ToOneFkSecondPass.doSecondPass(Map persistentClasses)`
`void` `SetSimpleValueTypeSecondPass.doSecondPass(Map persistentClasses)`
`void` `SecondaryTableSecondPass.doSecondPass(Map persistentClasses)`
`void` `SecondPass.doSecondPass(Map persistentClasses)`
`void` `ResultSetMappingSecondPass.doSecondPass(Map persistentClasses)`
`void` `PkDrivenByDefaultMapsIdSecondPass.doSecondPass(Map persistentClasses)`
`void` `OneToOneSecondPass.doSecondPass(Map persistentClasses)`
`void` `NamedSQLQuerySecondPass.doSecondPass(Map persistentClasses)`
`void` `JoinedSubclassFkSecondPass.doSecondPass(Map persistentClasses)`
`void` `IndexOrUniqueKeySecondPass.doSecondPass(Map persistentClasses)`
`void` `CreateKeySecondPass.doSecondPass(Map persistentClasses)`
`void` `CopyIdentifierComponentSecondPass.doSecondPass(Map persistentClasses)`
`void` `CollectionSecondPass.doSecondPass(Map persistentClasses)`
`org.hibernate.annotations.common.reflection.XClass` `WrappedInferredData.getClassOrElement()`
`org.hibernate.annotations.common.reflection.XClass` `PropertyPreloadedData.getClassOrElement()`
`org.hibernate.annotations.common.reflection.XClass` `PropertyInferredData.getClassOrElement()`
`org.hibernate.annotations.common.reflection.XClass` `PropertyData.getClassOrElement()` Returns the returned class itself or the element type if an array
`String` `WrappedInferredData.getClassOrElementName()`
`String` `PropertyPreloadedData.getClassOrElementName()`
`String` `PropertyInferredData.getClassOrElementName()`
`String` `PropertyData.getClassOrElementName()` Returns the returned class name itself or the element type if an array
`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` `WrappedInferredData.getPropertyClass()`
`org.hibernate.annotations.common.reflection.XClass` `PropertyPreloadedData.getPropertyClass()`
`org.hibernate.annotations.common.reflection.XClass` `PropertyInferredData.getPropertyClass()`
`org.hibernate.annotations.common.reflection.XClass` `PropertyData.getPropertyClass()` Return the class itself
`String` `WrappedInferredData.getPropertyName()`
`String` `PropertyPreloadedData.getPropertyName()`
`String` `PropertyInferredData.getPropertyName()`
`String` `PropertyData.getPropertyName()`
`static String` `HbmBinder.getTypeFromXML(org.dom4j.Element node)`
`String` `WrappedInferredData.getTypeName()`
`String` `PropertyPreloadedData.getTypeName()`
`String` `PropertyInferredData.getTypeName()`
`String` `PropertyData.getTypeName()` Returns the returned class name itself
`abstract void` `CollectionSecondPass.secondPass(Map persistentClasses, Map inheritedMetas)`
`protected void` `Configuration.secondPassCompile()`
`protected void` `Configuration.secondPassCompileForeignKeys(Table table, Set 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, int 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.
`String` `Cache71Dialect.getIdentityColumnString()`
`protected String` `CUBRIDDialect.getIdentityColumnString()`
`String` `InformixDialect.getIdentityColumnString(int type)`
`String` `Dialect.getIdentityColumnString(int type)` The syntax used during DDL to define a column as being an IDENTITY of a particular type.
`protected String` `Dialect.getIdentitySelectString()` Get the select command to use to retrieve the last generated IDENTITY value.
`String` `InformixDialect.getIdentitySelectString(String table, String column, int type)`
`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` `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)`
`Ejb3Configuration` `Ejb3Configuration.addClass(Class persistentClass)`
`Ejb3Configuration` `Ejb3Configuration.addFile(File xmlFile)`
`Ejb3Configuration` `Ejb3Configuration.addFile(String xmlFile)`
`Ejb3Configuration` `Ejb3Configuration.addInputStream(InputStream xmlInputStream)`
`Ejb3Configuration` `Ejb3Configuration.addPackage(String packageName)`
`Ejb3Configuration` `Ejb3Configuration.addResource(String path)`
`Ejb3Configuration` `Ejb3Configuration.addResource(String path, ClassLoader classLoader)`

Uses of MappingException in org.hibernate.engine

Methods in org.hibernate.engine that throw MappingException
`JoinSequence` `JoinSequence.addJoin(AssociationType associationType, String alias, int joinType, String[] referencingKey)`
`Object` `StatefulPersistenceContext.getCollectionOwner(Serializable key, CollectionPersister collectionPersister)` Get the entity that owns this persistent collection
`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)` Does the given version belong to a new instance?
`boolean` `StatefulPersistenceContext.reassociateIfUninitializedProxy(Object value)` Takes the given object and, if it represents a proxy, reassociates it with this event source.
`boolean` `PersistenceContext.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
`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
`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

Methods in org.hibernate.engine.query 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.hql

Methods in org.hibernate.hql 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.
`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.ast

Methods in org.hibernate.hql.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.classic

Methods in org.hibernate.hql.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.id

Methods in org.hibernate.id that throw MappingException
`void` `UUIDGenerator.configure(Type type, Properties params, Dialect d)`
`void` `SequenceIdentityGenerator.configure(Type type, Properties params, Dialect dialect)`
`void` `SequenceHiLoGenerator.configure(Type type, Properties params, Dialect d)`
`void` `SequenceGenerator.configure(Type type, Properties params, Dialect dialect)`
`void` `SelectGenerator.configure(Type type, Properties params, Dialect d)`
`void` `MultipleHiLoPerTableGenerator.configure(Type type, Properties params, Dialect dialect)`
`void` `IncrementGenerator.configure(Type type, Properties params, Dialect dialect)`
`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` `Assigned.configure(Type type, Properties params, Dialect d)`

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)` Configure this instance, given the value of parameters specified by the user as `<param>` elements.
`void` `SequenceStyleGenerator.configure(Type type, Properties params, Dialect dialect)` Configure this instance, given the value of parameters specified by the user as `<param>` elements.

Uses of MappingException in org.hibernate.impl

Methods in org.hibernate.impl 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)` Return the names of all persistent (mapped) classes that extend or implement the given class or interface, accounting for implicit/explicit polymorphism settings and excluding mapped subclasses/joined-subclasses of other classes in the result.
`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.impl 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.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 int` `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 int` `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, int 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 int` `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 int` `CriteriaJoinWalker.getJoinType(AssociationType associationType, FetchMode config, PropertyPath path, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth, CascadeStyle cascadeStyle)`
`protected int` `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 int` `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` `RootClass.addSubclass(Subclass subclass)`
`void` `PersistentClass.addSubclass(Subclass subclass)`
`protected void` `PersistentClass.checkColumnDuplication(Set distinctColumns, Iterator columns)`
`protected void` `PersistentClass.checkPropertyColumnDuplication(Set distinctColumns, Iterator properties)`
`void` `Map.createAllKeys()`
`void` `Collection.createAllKeys()`
`void` `Value.createForeignKey()`
`abstract void` `ToOne.createForeignKey()`
`void` `SimpleValue.createForeignKey()`
`void` `OneToOne.createForeignKey()`
`void` `ManyToOne.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()`
`CollectionType` `List.getDefaultCollectionType()`
`abstract CollectionType` `Collection.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()`
`abstract Type` `ToOne.getType()`
`Type` `SimpleValue.getType()`
`Type` `Property.getType()`
`Type` `OneToOne.getType()`
`Type` `ManyToOne.getType()`
`Type` `DependantValue.getType()`
`Type` `Component.getType()`
`Type` `Collection.getType()`
`Type` `Any.getType()`
`boolean` `Value.isValid(Mapping mapping)`
`boolean` `ToOne.isValid(Mapping mapping)`
`boolean` `SimpleValue.isValid(Mapping mapping)`
`boolean` `Property.isValid(Mapping mapping)`
`boolean` `OneToMany.isValid(Mapping mapping)`
`boolean` `Collection.isValid(Mapping mapping)`
`void` `ForeignKey.setReferencedTable(Table referencedTable)`
`void` `Value.setTypeUsingReflection(String className, String propertyName)`
`void` `ToOne.setTypeUsingReflection(String className, String propertyName)`
`void` `SimpleValue.setTypeUsingReflection(String className, String propertyName)`
`void` `Component.setTypeUsingReflection(String className, String propertyName)`
`void` `Any.setTypeUsingReflection(String className, String propertyName)`
`void` `UnionSubclass.validate(Mapping mapping)`
`void` `SingleTableSubclass.validate(Mapping mapping)`
`void` `Set.validate(Mapping mapping)`
`void` `RootClass.validate(Mapping mapping)`
`void` `PersistentClass.validate(Mapping mapping)`
`void` `JoinedSubclass.validate(Mapping mapping)`
`void` `IndexedCollection.validate(Mapping mapping)`
`void` `IdentifierCollection.validate(Mapping mapping)`
`void` `Collection.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.persister.collection

Methods in org.hibernate.persister.collection that throw MappingException
`protected CollectionInitializer` `OneToManyPersister.createCollectionInitializer(LoadQueryInfluencers loadQueryInfluencers)` Create the `OneToManyLoader`
`protected CollectionInitializer` `BasicCollectionPersister.createCollectionInitializer(LoadQueryInfluencers loadQueryInfluencers)` Create the `CollectionLoader`
`protected abstract CollectionInitializer` `AbstractCollectionPersister.createCollectionInitializer(LoadQueryInfluencers loadQueryInfluencers)`
`String` `OneToManyPersister.filterFragment(String alias)`
`protected String` `AbstractCollectionPersister.filterFragment(String alias)`
`String` `AbstractCollectionPersister.filterFragment(String alias, Map enabledFilters)`
`String` `AbstractCollectionPersister.oneToManyFilterFragment(String alias)`
`void` `CollectionPersister.postInstantiate()`
`void` `AbstractCollectionPersister.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()`
`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(PersistentClass model)` Must be called by subclasses, at the end of their constructors
`String` `SingleTableEntityPersister.oneToManyFilterFragment(String alias)`
`String` `Joinable.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.getDom4jPropertyAccessor(String nodeName, Type type, SessionFactoryImplementor factory)`
`static PropertyAccessor` `PropertyAccessorFactory.getDynamicMapPropertyAccessor()`
`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
`String` `CollectionType.getAssociatedEntityName(SessionFactoryImplementor factory)`
`String` `AssociationType.getAssociatedEntityName(SessionFactoryImplementor factory)` Get the entity name of the associated entity
`String` `AnyType.getAssociatedEntityName(SessionFactoryImplementor factory)`
`Joinable` `EntityType.getAssociatedJoinable(SessionFactoryImplementor factory)` Retrieves the `Joinable` defining the associated entity.
`Joinable` `CollectionType.getAssociatedJoinable(SessionFactoryImplementor factory)`
`Joinable` `AssociationType.getAssociatedJoinable(SessionFactoryImplementor factory)` Get the "persister" for this association - a class or collection persister
`int` `Type.getColumnSpan(Mapping mapping)` How many columns are used to persist this type.
`int` `SpecialOneToOneType.getColumnSpan(Mapping mapping)`
`int` `OneToOneType.getColumnSpan(Mapping session)`
`int` `MetaType.getColumnSpan(Mapping mapping)`
`int` `ManyToOneType.getColumnSpan(Mapping mapping)`
`int` `CompositeCustomType.getColumnSpan(Mapping mapping)`
`int` `ComponentType.getColumnSpan(Mapping mapping)`
`int` `CollectionType.getColumnSpan(Mapping session)`
`int` `AnyType.getColumnSpan(Mapping session)`
`int` `AbstractStandardBasicType.getColumnSpan(Mapping mapping)`
`int` `AbstractLobType.getColumnSpan(Mapping mapping)` Deprecated.
`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` `EntityType.getOnCondition(String alias, SessionFactoryImplementor factory, Map enabledFilters)`
`String` `CollectionType.getOnCondition(String alias, SessionFactoryImplementor factory, Map enabledFilters)`
`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` `AnyType.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[]` `Type.sqlTypes(Mapping mapping)` Return the JDBC types codes (per `Types`) for the columns mapped by this type.
`int[]` `SpecialOneToOneType.sqlTypes(Mapping mapping)`
`int[]` `SerializableToBlobType.sqlTypes(Mapping mapping)`
`int[]` `OneToOneType.sqlTypes(Mapping session)`
`int[]` `MetaType.sqlTypes(Mapping mapping)`
`int[]` `ManyToOneType.sqlTypes(Mapping mapping)`
`int[]` `CompositeCustomType.sqlTypes(Mapping mapping)`
`int[]` `ComponentType.sqlTypes(Mapping mapping)`
`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)`

Uses of MappingException in org.hibernate.util

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

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