Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## 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.dialect | This package abstracts the SQL dialect of the underlying database.
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` | `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 name or auto-flush synchronization.
`SQLQuery` | `SQLQuery.addSynchronizedEntityName(String entityName)` Adds an entity name or auto-flush synchronization.

Uses of MappingException in org.hibernate.cfg

Methods in org.hibernate.cfg that throw MappingException
`protected void` | `Configuration.add(org.dom4j.Document doc)`
`Configuration` | `Configuration.addCacheableFile(File xmlFile)` Add a cached mapping file.
`Configuration` | `Configuration.addCacheableFile(String xmlFile)` Add a cacheable mapping file.
`Configuration` | `Configuration.addClass(Class persistentClass)` Read a mapping as an application resouurce 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.
`void` | `Mappings.addClass(PersistentClass persistentClass)`
`void` | `Mappings.addCollection(Collection collection)`
`Table` | `Mappings.addDenormalizedTable(String schema, String catalog, String name, boolean isAbstract, String subselect, Table includedTable)`
`Configuration` | `Configuration.addDirectory(File dir)` Read all mapping documents from a directory tree.
`Configuration` | `Configuration.addDocument(Document doc)` Read mappings from a DOM `Document`
`Configuration` | `Configuration.addFile(File xmlFile)` Read mappings from a particular XML file
`Configuration` | `Configuration.addFile(String xmlFile)` Read mappings from a particular XML file
`void` | `Mappings.addImport(String className, String rename)`
`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.
`void` | `Mappings.addQuery(String name, NamedQueryDefinition query)`
`Configuration` | `Configuration.addResource(String resourceName)` Read mappings as a application resourceName (i.e.
`Configuration` | `Configuration.addResource(String resourceName, ClassLoader classLoader)` Read mappings as a application resource (i.e.
`void` | `Mappings.addSQLQuery(String name, NamedSQLQueryDefinition query)`
`Configuration` | `Configuration.addURL(URL url)` Read mappings from a `URL`
`Configuration` | `Configuration.addXML(String xml)` Read mappings from a `String`
`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` | `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.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(org.dom4j.Document doc, Mappings mappings, Map inheritedMetas)` 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` | `ResultSetMappingSecondPass.doSecondPass(Map persistentClasses)`
`void` | `NamedSQLQuerySecondPass.doSecondPass(Map persistentClasses)`
`void` | `SecondPass.doSecondPass(Map persistentClasses)`
`void` | `CollectionSecondPass.doSecondPass(Map persistentClasses)`
`static String` | `HbmBinder.getTypeFromXML(org.dom4j.Element node)`
`abstract void` | `CollectionSecondPass.secondPass(Map persistentClasses, Map inheritedMetas)`
`protected void` | `Configuration.secondPassCompile()`
`protected void` | `Configuration.secondPassCompileForeignKeys(Table table, Set done)`
`Configuration` | `Configuration.setCacheConcurrencyStrategy(String clazz, String concurrencyStrategy)` Set up a cache for an entity class
`void` | `Configuration.setCacheConcurrencyStrategy(String clazz, String concurrencyStrategy, String region)`
`Configuration` | `Configuration.setCollectionCacheConcurrencyStrategy(String collectionRole, String concurrencyStrategy)` Set up a cache for a collection role
`void` | `Configuration.setCollectionCacheConcurrencyStrategy(String collectionRole, String concurrencyStrategy, String region)`

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` | `H2Dialect.getCreateSequenceString(String sequenceName)`
`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` | `H2Dialect.getDropSequenceString(String sequenceName)`
`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.
`String` | `Cache71Dialect.getIdentityColumnString()`
`protected String` | `Dialect.getIdentityColumnString()` The syntax used during DDL to define a column as being an IDENTITY.
`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 particuar table
`String` | `InformixDialect.getIdentitySelectString(String table, String column, int type)`
`String` | `Dialect.getSelectSequenceNextValString(String sequenceName)` Generate the select expression fragment that will retreive 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 retreive the next value of a sequence.

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` | `PersistenceContext.getCollectionOwner(Serializable key, CollectionPersister collectionPersister)` Get the entity that owns this persistent collection
`Object` | `StatefulPersistenceContext.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` | `PersistenceContext.reassociateIfUninitializedProxy(Object value)` Takes the given object and, if it represents a proxy, reassociates it with this event source.
`boolean` | `StatefulPersistenceContext.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
`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

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` | `MultipleHiLoPerTableGenerator.configure(Type type, Properties params, Dialect dialect)`
`void` | `SequenceIdentityGenerator.configure(Type type, Properties params, Dialect dialect)`
`void` | `Assigned.configure(Type type, Properties params, Dialect d)`
`void` | `SequenceHiLoGenerator.configure(Type type, Properties params, Dialect d)`
`void` | `SequenceGenerator.configure(Type type, Properties params, Dialect dialect)`
`void` | `ForeignGenerator.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` | `SelectGenerator.configure(Type type, Properties params, Dialect d)`
`void` | `IncrementGenerator.configure(Type type, Properties params, Dialect dialect)`
`static IdentifierGenerator` | `IdentifierGeneratorFactory.create(String strategy, 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.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 type, FetchMode config, String path, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth, CascadeStyle cascadeStyle)` Get the join type (inner, outer, etc) or -1 if the association should not be joined.
`protected String` | `AbstractEntityJoinWalker.getWhereFragment()`
`protected void` | `AbstractEntityJoinWalker.initAll(String whereString, String orderByString, LockMode lockMode)`
`protected void` | `JoinWalker.initPersisters(List associations, LockMode lockMode)`
`protected void` | `AbstractEntityJoinWalker.initProjection(String projectionString, String whereString, String orderByString, String groupByString, LockMode lockMode)`
`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)` For an entity class, return a list of associations to be fetched by outerjoin

Constructors in org.hibernate.loader that throw MappingException
`OuterJoinableAssociation(AssociationType joinableType, String lhsAlias, String[] lhsColumns, String rhsAlias, int joinType, 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, Map enabledFilters)`
`static CollectionInitializer` | `BatchingCollectionInitializer.createBatchingOneToManyInitializer(QueryableCollection persister, int maxBatchSize, SessionFactoryImplementor factory, Map enabledFilters)`
`protected int` | `BasicCollectionJoinWalker.getJoinType(AssociationType type, FetchMode config, String path, Set visitedAssociations, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth)` We can use an inner join for first many-to-many association

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

Uses of MappingException in org.hibernate.loader.criteria

Methods in org.hibernate.loader.criteria that throw MappingException
`protected int` | `CriteriaJoinWalker.getJoinType(AssociationType type, FetchMode config, String path, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth, CascadeStyle cascadeStyle)`
`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, Map enabledFilters)`

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, Map enabledFilters)`
`EntityJoinWalker(OuterJoinLoadable persister, String[] uniqueKey, int batchSize, LockMode lockMode, SessionFactoryImplementor factory, Map enabledFilters)`
`EntityLoader(OuterJoinLoadable persister, int batchSize, LockMode lockMode, SessionFactoryImplementor factory, Map enabledFilters)`
`EntityLoader(OuterJoinLoadable persister, LockMode lockMode, SessionFactoryImplementor factory, Map enabledFilters)`
`EntityLoader(OuterJoinLoadable persister, String[] uniqueKey, Type uniqueKeyType, int batchSize, LockMode lockMode, SessionFactoryImplementor factory, Map enabledFilters)`

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()`
`void` | `ManyToOne.createForeignKey()`
`void` | `OneToOne.createForeignKey()`
`void` | `SimpleValue.createForeignKey()`
`abstract void` | `ToOne.createForeignKey()`
`IdentifierGenerator` | `KeyValue.createIdentifierGenerator(Dialect dialect, String defaultCatalog, String defaultSchema, RootClass rootClass)`
`IdentifierGenerator` | `SimpleValue.createIdentifierGenerator(Dialect dialect, String defaultCatalog, String defaultSchema, RootClass rootClass)`
`CascadeStyle` | `Property.getCascadeStyle()`
`Class` | `Component.getComponentClass()`
`CollectionType` | `List.getDefaultCollectionType()`
`CollectionType` | `Array.getDefaultCollectionType()`
`abstract CollectionType` | `Collection.getDefaultCollectionType()`
`Class` | `Array.getElementClass()`
`Getter` | `Property.getGetter(Class clazz)`
`Class` | `PersistentClass.getMappedClass()`
`Property` | `Component.getProperty(String propertyName)`
`Property` | `PersistentClass.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` | `Property.getType()`
`Type` | `Component.getType()`
`Type` | `ManyToOne.getType()`
`Type` | `OneToOne.getType()`
`Type` | `SimpleValue.getType()`
`abstract Type` | `ToOne.getType()`
`Type` | `Collection.getType()`
`Type` | `DependantValue.getType()`
`Type` | `Any.getType()`
`boolean` | `Value.isValid(Mapping mapping)`
`boolean` | `Property.isValid(Mapping mapping)`
`boolean` | `OneToMany.isValid(Mapping mapping)`
`boolean` | `SimpleValue.isValid(Mapping mapping)`
`boolean` | `ToOne.isValid(Mapping mapping)`
`boolean` | `Collection.isValid(Mapping mapping)`
`void` | `ForeignKey.setReferencedTable(Table referencedTable)`
`void` | `Value.setTypeUsingReflection(String className, String propertyName)`
`void` | `Component.setTypeUsingReflection(String className, String propertyName)`
`void` | `SimpleValue.setTypeUsingReflection(String className, String propertyName)`
`void` | `ToOne.setTypeUsingReflection(String className, String propertyName)`
`void` | `Any.setTypeUsingReflection(String className, String propertyName)`
`void` | `JoinedSubclass.validate(Mapping mapping)`
`void` | `RootClass.validate(Mapping mapping)`
`void` | `SingleTableSubclass.validate(Mapping mapping)`
`void` | `IdentifierCollection.validate(Mapping mapping)`
`void` | `IndexedCollection.validate(Mapping mapping)`
`void` | `Collection.validate(Mapping mapping)`
`void` | `UnionSubclass.validate(Mapping mapping)`
`void` | `Set.validate(Mapping mapping)`
`void` | `PersistentClass.validate(Mapping mapping)`

Constructors in org.hibernate.mapping that throw MappingException
`Component(Collection collection)`
`Component(Component component)`
`Component(Join join)`
`Component(PersistentClass owner)`
`OneToMany(PersistentClass owner)`
`OneToOne(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(Map enabledFilters)` Create the `OneToManyLoader`
`protected abstract CollectionInitializer` | `AbstractCollectionPersister.createCollectionInitializer(Map enabledFilters)`
`protected CollectionInitializer` | `BasicCollectionPersister.createCollectionInitializer(Map enabledFilters)` Create the `CollectionLoader`
`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, CacheConcurrencyStrategy cache, Configuration cfg, SessionFactoryImplementor factory)`
`BasicCollectionPersister(Collection collection, CacheConcurrencyStrategy cache, Configuration cfg, SessionFactoryImplementor factory)`
`CompositeElementPropertyMapping(String[] elementColumns, String[] elementFormulaTemplates, AbstractComponentType compositeType, Mapping factory)`
`ElementPropertyMapping(String[] elementColumns, Type type)`
`OneToManyPersister(Collection collection, CacheConcurrencyStrategy cache, 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, Map enabledFilters)`
`protected void` | `AbstractEntityPersister.createUniqueKeyLoaders()`
`protected abstract String` | `AbstractEntityPersister.filterFragment(String alias)`
`String` | `SingleTableEntityPersister.filterFragment(String alias)`
`String` | `AbstractEntityPersister.filterFragment(String alias, Map enabledFilters)`
`String` | `Joinable.filterFragment(String alias, Map enabledFilters)` Get the where clause filter, given a query alias and considering enabled session filters
`Type` | `AbstractEntityPersister.getPropertyType(String propertyName)`
`Type` | `EntityPersister.getPropertyType(String propertyName)` Get the type of a particular property by name.
`protected void` | `AbstractPropertyMapping.initComponentPropertyPaths(String path, AbstractComponentType type, String[] columns, String[] formulaTemplates, Mapping factory)`
`protected void` | `AbstractPropertyMapping.initIdentifierPropertyPaths(String path, EntityType etype, String[] columns, Mapping factory)`
`protected void` | `AbstractEntityPersister.initPropertyPaths(Mapping mapping)`
`protected void` | `AbstractPropertyMapping.initPropertyPaths(String path, Type type, String[] columns, String[] formulaTemplates, Mapping factory)`
`protected void` | `AbstractEntityPersister.initSubclassPropertyAliasesMap(PersistentClass model)` Must be called by subclasses, at the end of their constructors
`String` | `AbstractEntityPersister.oneToManyFilterFragment(String alias)`
`String` | `Joinable.oneToManyFilterFragment(String alias)`
`String` | `SingleTableEntityPersister.oneToManyFilterFragment(String alias)`
`protected void` | `AbstractEntityPersister.postConstruct(Mapping mapping)`
`void` | `AbstractEntityPersister.postInstantiate()`
`void` | `EntityPersister.postInstantiate()` Finish the initialization of this object.

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` | `AnyType.getAssociatedEntityName(SessionFactoryImplementor factory)`
`String` | `AssociationType.getAssociatedEntityName(SessionFactoryImplementor factory)` Get the entity name of the associated entity
`Joinable` | `CollectionType.getAssociatedJoinable(SessionFactoryImplementor factory)`
`Joinable` | `AssociationType.getAssociatedJoinable(SessionFactoryImplementor factory)` Get the "persister" for this association - a class or collection persister
`Joinable` | `EntityType.getAssociatedJoinable(SessionFactoryImplementor factory)` Retrieves the `Joinable` defining the associated entity.
`int` | `CompositeCustomType.getColumnSpan(Mapping mapping)`
`int` | `OneToOneType.getColumnSpan(Mapping session)`
`int` | `CollectionType.getColumnSpan(Mapping session)`
`int` | `Type.getColumnSpan(Mapping mapping)` How many columns are used to persist this type.
`int` | `AnyType.getColumnSpan(Mapping session)`
`int` | `ManyToOneType.getColumnSpan(Mapping mapping)`
`int` | `SpecialOneToOneType.getColumnSpan(Mapping mapping)`
`int` | `ComponentType.getColumnSpan(Mapping mapping)`
`int` | `MetaType.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` | `CollectionType.getOnCondition(String alias, SessionFactoryImplementor factory, Map enabledFilters)`
`String` | `AnyType.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` | `EntityType.getOnCondition(String alias, SessionFactoryImplementor factory, Map enabledFilters)`
`static Type` | `TypeFactory.heuristicType(String typeName)` Uses heuristics to deduce a Hibernate type given a string naming the type or Java class.
`static Type` | `TypeFactory.heuristicType(String typeName, Properties parameters)` Uses heuristics to deduce a Hibernate type given a string naming the type or Java class.
`int[]` | `BlobType.sqlTypes(Mapping mapping)`
`int[]` | `CompositeCustomType.sqlTypes(Mapping mapping)`
`int[]` | `OneToOneType.sqlTypes(Mapping session)`
`int[]` | `CollectionType.sqlTypes(Mapping session)`
`int[]` | `Type.sqlTypes(Mapping mapping)` Return the SQL type codes for the columns mapped by this type.
`int[]` | `AnyType.sqlTypes(Mapping mapping)`
`int[]` | `ManyToOneType.sqlTypes(Mapping mapping)`
`int[]` | `SpecialOneToOneType.sqlTypes(Mapping mapping)`
`int[]` | `ComponentType.sqlTypes(Mapping mapping)`
`int[]` | `ClobType.sqlTypes(Mapping mapping)`
`int[]` | `MetaType.sqlTypes(Mapping mapping)`

Constructors in org.hibernate.type that throw MappingException
`CompositeCustomType(Class userTypeClass, Properties parameters)`
`CustomType(Class userTypeClass, Properties parameters)`

Uses of MappingException in org.hibernate.util

Methods in org.hibernate.util that throw MappingException
`static Getter` | `ReflectHelper.getGetter(Class theClass, String name)`
`static Class` | `ReflectHelper.reflectedPropertyClass(String className, String name)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES