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.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
class	PropertyNotFoundException Indicates that an expected getter or setter method could not be found on a class.

Uses of MappingException in org.hibernate.cfg

Methods in org.hibernate.cfg that throw MappingException

void	SecondPass.doSecondPass(Map persistentClasses, Map inheritedMetas)
void	ResultSetMappingSecondPass.doSecondPass(Map persistentClasses, Map inheritedMetas)
void	NamedSQLQuerySecondPass.doSecondPass(Map persistentClasses, Map inheritedMetas)
void	Mappings.addClass(PersistentClass persistentClass)
void	Mappings.addCollection(Collection collection)
void	Mappings.addImport(String className, String rename)
Table	Mappings.addDenormalizedTable(String schema, String catalog, String name, boolean isAbstract, String subselect, Table includedTable)
void	Mappings.addQuery(String name, NamedQueryDefinition query)
void	Mappings.addSQLQuery(String name, NamedSQLQueryDefinition query)
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.bindClass(org.dom4j.Element node, PersistentClass persistentClass, Mappings mappings, Map inheritedMetas)
static void	HbmBinder.bindUnionSubclass(org.dom4j.Element node, UnionSubclass unionSubclass, Mappings mappings, Map inheritedMetas)
static void	HbmBinder.bindSubclass(org.dom4j.Element node, Subclass subclass, Mappings mappings, Map inheritedMetas)
static void	HbmBinder.bindJoinedSubclass(org.dom4j.Element node, JoinedSubclass joinedSubclass, Mappings mappings, Map inheritedMetas)
static void	HbmBinder.bindColumns(org.dom4j.Element node, SimpleValue simpleValue, boolean isNullable, boolean autoColumn, String propertyPath, Mappings mappings)
static void	HbmBinder.bindSimpleValue(org.dom4j.Element node, SimpleValue simpleValue, boolean isNullable, String path, Mappings mappings)
static void	HbmBinder.bindProperty(org.dom4j.Element node, Property property, Mappings mappings, Map inheritedMetas)
static void	HbmBinder.bindCollection(org.dom4j.Element node, Collection collection, String className, String path, Mappings mappings) Called for all collections
static void	HbmBinder.bindManyToOne(org.dom4j.Element node, ManyToOne manyToOne, String path, boolean isNullable, Mappings mappings)
static void	HbmBinder.bindAny(org.dom4j.Element node, Any any, boolean isNullable, Mappings mappings)
static void	HbmBinder.bindOneToOne(org.dom4j.Element node, OneToOne oneToOne, String path, boolean isNullable, Mappings mappings)
static void	HbmBinder.bindOneToMany(org.dom4j.Element node, OneToMany oneToMany, Mappings mappings)
static void	HbmBinder.bindArray(org.dom4j.Element node, Array array, String prefix, String path, Mappings mappings) Called for arrays and primitive arrays
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.bindComponent(org.dom4j.Element node, Component component, String ownerClassName, String parentProperty, String path, boolean isNullable, boolean isEmbedded, Mappings mappings, Map inheritedMetas, boolean isIdentifierMapper)
static String	HbmBinder.getTypeFromXML(org.dom4j.Element node)
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)
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.bindIdentifierCollectionSecondPass(org.dom4j.Element node, IdentifierCollection collection, Map persistentClasses, Mappings mappings, Map inheritedMetas)
static void	HbmBinder.bindMapSecondPass(org.dom4j.Element node, Map map, Map classes, Mappings mappings, Map inheritedMetas) Called for Maps
static void	HbmBinder.bindCollectionSecondPass(org.dom4j.Element node, Collection collection, Map persistentClasses, Mappings mappings, Map inheritedMetas) Called for all collections
Configuration	Configuration.addFile(String xmlFile) Read mappings from a particular XML file
Configuration	Configuration.addFile(File xmlFile) Read mappings from a particular XML file
Configuration	Configuration.addCacheableFile(File xmlFile) If a cached xmlFile + ".bin" exists and is newer than xmlFile the ".bin" file will be read directly.
Configuration	Configuration.addCacheableFile(String xmlFile)
Configuration	Configuration.addXML(String xml) Read mappings from a String
Configuration	Configuration.addURL(URL url) Read mappings from a URL
Configuration	Configuration.addDocument(org.w3c.dom.Document doc) Read mappings from a DOM Document
protected void	Configuration.add(org.dom4j.Document doc)
Configuration	Configuration.addInputStream(InputStream xmlInputStream) Read mappings from an InputStream
Configuration	Configuration.addResource(String path, ClassLoader classLoader) Read mappings from an application resource
Configuration	Configuration.addResource(String path) Read mappings from an application resource trying different classloaders.
Configuration	Configuration.addClass(Class persistentClass) Read a mapping from an application resource, using a convention.
Configuration	Configuration.addJar(File jar) Read all mappings from a jar file
Configuration	Configuration.addDirectory(File dir) Read all mapping documents from a directory tree.
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)
void	CollectionSecondPass.doSecondPass(Map persistentClasses, Map inheritedMetas)
abstract void	CollectionSecondPass.secondPass(Map persistentClasses, Map inheritedMetas)

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
String	InformixDialect.getIdentitySelectString(String table, String column, int type)
String	InformixDialect.getIdentityColumnString(int type)
protected String	Dialect.getIdentitySelectString()
String	Dialect.getIdentitySelectString(String table, String column, int type) The syntax that returns the identity value of the last insert, if identity column key generation is supported.
protected String	Dialect.getIdentityColumnString()
String	Dialect.getIdentityColumnString(int type) The keyword used to specify an identity column, if identity column key generation is supported.
String	Dialect.getSequenceNextValString(String sequenceName) Generate the appropriate select statement to to retreive the next value of a sequence, if sequences are supported.
String	Dialect.getSelectSequenceNextValString(String sequenceName) Generate the select expression fragment that will retreive the next value of a sequence, if sequences are supported.
protected String	Dialect.getCreateSequenceString(String sequenceName) The syntax used to create a sequence, if sequences are supported.
String[]	Dialect.getCreateSequenceStrings(String sequenceName) The multiline script used to create a sequence, if sequences are supported.
protected String	Dialect.getDropSequenceString(String sequenceName) The syntax used to drop a sequence, if sequences are supported.
String[]	Dialect.getDropSequenceStrings(String sequenceName) The multiline script used to drop a sequence, if sequences are supported.

Uses of MappingException in org.hibernate.engine

Methods in org.hibernate.engine that throw MappingException

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.
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
Object	StatefulPersistenceContext.getCollectionOwner(Serializable key, CollectionPersister collectionPersister) Get the entity that owns this persistent collection
EntityPersister	SessionFactoryImplementor.getEntityPersister(String entityName) Get the persister for the named entity
CollectionPersister	SessionFactoryImplementor.getCollectionPersister(String role) Get the persister object for a collection role
String[]	SessionFactoryImplementor.getImplementors(String className) Get the names of all persistent classes that implement/extend the given interface/class
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
Object	PersistenceContext.getCollectionOwner(Serializable key, CollectionPersister collectionPersister) Get the entity that owns this persistent collection
Type	Mapping.getIdentifierType(String className)
String	Mapping.getIdentifierPropertyName(String className)
Type	Mapping.getReferencedPropertyType(String className, String propertyName)
JoinSequence	JoinSequence.addJoin(AssociationType associationType, String alias, int joinType, String[] referencingKey)
JoinFragment	JoinSequence.toJoinFragment()
JoinFragment	JoinSequence.toJoinFragment(Map enabledFilters, boolean includeExtraJoins)
JoinFragment	JoinSequence.toJoinFragment(Map enabledFilters, boolean includeExtraJoins, String extraOnClause)

Uses of MappingException in org.hibernate.engine.query

Methods in org.hibernate.engine.query that throw MappingException

HQLQueryPlan	QueryPlanCache.getHQLQueryPlan(String queryString, boolean shallow, Map enabledFilters)
FilterQueryPlan	QueryPlanCache.getFilterQueryPlan(String filterString, String collectionRole, 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.
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)
void	FilterTranslator.compile(String collectionRole, Map replacements, boolean shallow) Compile a filter.

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	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)
static IdentifierGenerator	IdentifierGeneratorFactory.create(String strategy, 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	Assigned.configure(Type type, Properties params, Dialect d)

Uses of MappingException in org.hibernate.impl

Methods in org.hibernate.impl that throw MappingException

Query	SessionImpl.getNamedQuery(String queryName)
EntityPersister	SessionFactoryImpl.getEntityPersister(String entityName)
CollectionPersister	SessionFactoryImpl.getCollectionPersister(String role)
Type	SessionFactoryImpl.getIdentifierType(String className)
String	SessionFactoryImpl.getIdentifierPropertyName(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.
Type	SessionFactoryImpl.getReferencedPropertyType(String className, String propertyName)
Query	AbstractSessionImpl.getNamedQuery(String queryName)
Query	AbstractSessionImpl.getNamedSQLQuery(String queryName)

Constructors in org.hibernate.impl that throw MappingException

ScrollableResultsImpl(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)

AbstractScrollableResults(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.validateJoin(String path)
void	OuterJoinableAssociation.addManyToManyJoin(JoinFragment outerjoin, QueryableCollection collection)
protected void	JoinWalker.walkEntityTree(OuterJoinLoadable persister, String alias) For an entity class, return a list of associations to be fetched by outerjoin
protected void	JoinWalker.walkCollectionTree(QueryableCollection persister, String alias) For a collection role, return a list of associations to be fetched by outerjoin
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 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 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 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 String	JoinWalker.orderBy(List associations) Get the order by string required for collection fetching
protected void	JoinWalker.initPersisters(List associations, LockMode lockMode)
protected String	JoinWalker.selectString(List associations) Generate a select list of columns containing all properties of the entity classes
protected void	AbstractEntityJoinWalker.initAll(String whereString, String orderByString, LockMode lockMode)
protected void	AbstractEntityJoinWalker.initProjection(String projectionString, String whereString, String orderByString, String groupByString, LockMode lockMode)
protected String	AbstractEntityJoinWalker.getWhereFragment() Don't bother with the discriminator, unless overridded by subclass

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.createBatchingOneToManyInitializer(QueryableCollection persister, int maxBatchSize, SessionFactoryImplementor factory, Map enabledFilters)
static CollectionInitializer	BatchingCollectionInitializer.createBatchingCollectionInitializer(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

SubselectOneToManyLoader(QueryableCollection persister, String subquery, Collection entityKeys, QueryParameters queryParameters, Map namedParameterLocMap, SessionFactoryImplementor factory, Map enabledFilters)

SubselectCollectionLoader(QueryableCollection persister, String subquery, Collection entityKeys, QueryParameters queryParameters, Map namedParameterLocMap, SessionFactoryImplementor factory, Map enabledFilters)

OneToManyLoader(QueryableCollection oneToManyPersister, SessionFactoryImplementor session, Map enabledFilters)

OneToManyLoader(QueryableCollection oneToManyPersister, int batchSize, SessionFactoryImplementor factory, Map enabledFilters)

OneToManyLoader(QueryableCollection oneToManyPersister, int batchSize, String subquery, SessionFactoryImplementor factory, Map enabledFilters)

OneToManyJoinWalker(QueryableCollection oneToManyPersister, int batchSize, String subquery, SessionFactoryImplementor factory, Map enabledFilters)

BasicCollectionLoader(QueryableCollection collectionPersister, SessionFactoryImplementor session, Map enabledFilters)

BasicCollectionLoader(QueryableCollection collectionPersister, int batchSize, SessionFactoryImplementor factory, Map enabledFilters)

BasicCollectionLoader(QueryableCollection collectionPersister, int batchSize, String subquery, SessionFactoryImplementor factory, Map enabledFilters)

BasicCollectionJoinWalker(QueryableCollection collectionPersister, int batchSize, String subquery, 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

EntityLoader(OuterJoinLoadable persister, LockMode lockMode, SessionFactoryImplementor factory, Map enabledFilters)

EntityLoader(OuterJoinLoadable persister, int batchSize, LockMode lockMode, SessionFactoryImplementor factory, Map enabledFilters)

EntityLoader(OuterJoinLoadable persister, String[] uniqueKey, Type uniqueKeyType, int batchSize, LockMode lockMode, SessionFactoryImplementor factory, Map enabledFilters)

EntityJoinWalker(OuterJoinLoadable persister, String[] uniqueKey, int batchSize, LockMode lockMode, SessionFactoryImplementor factory, Map enabledFilters)

CollectionElementLoader(QueryableCollection collectionPersister, SessionFactoryImplementor factory, Map enabledFilters)

CascadeEntityLoader(OuterJoinLoadable persister, CascadingAction action, SessionFactoryImplementor factory)

CascadeEntityJoinWalker(OuterJoinLoadable persister, CascadingAction action, SessionFactoryImplementor factory)

Uses of MappingException in org.hibernate.mapping

Methods in org.hibernate.mapping that throw MappingException

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

Constructors in org.hibernate.mapping that throw MappingException

OneToOne(Table table, PersistentClass owner)

OneToMany(PersistentClass owner)

Component(PersistentClass owner)

Component(Component component)

Component(Join join)

Component(Collection collection)

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
String	OneToManyPersister.filterFragment(String alias)
void	CollectionPersister.postInstantiate()
protected CollectionInitializer	BasicCollectionPersister.createCollectionInitializer(Map enabledFilters) Create the CollectionLoader
void	AbstractCollectionPersister.postInstantiate()
protected abstract CollectionInitializer	AbstractCollectionPersister.createCollectionInitializer(Map enabledFilters)
protected String	AbstractCollectionPersister.filterFragment(String alias)
String	AbstractCollectionPersister.filterFragment(String alias, Map enabledFilters)
String	AbstractCollectionPersister.oneToManyFilterFragment(String alias)

Constructors in org.hibernate.persister.collection that throw MappingException

OneToManyPersister(Collection collection, CacheConcurrencyStrategy cache, Configuration cfg, SessionFactoryImplementor factory)

ElementPropertyMapping(String[] elementColumns, Type type)

CompositeElementPropertyMapping(String[] elementColumns, String[] elementFormulaTemplates, AbstractComponentType compositeType, Mapping factory)

BasicCollectionPersister(Collection collection, CacheConcurrencyStrategy cache, Configuration cfg, SessionFactoryImplementor factory)

AbstractCollectionPersister(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

String	SingleTableEntityPersister.filterFragment(String alias)
String	SingleTableEntityPersister.oneToManyFilterFragment(String alias)
String	Joinable.filterFragment(String alias, Map enabledFilters) Get the where clause filter, given a query alias and considering enabled session filters
String	Joinable.oneToManyFilterFragment(String alias)
void	EntityPersister.postInstantiate() Finish the initialization of this object, once all ClassPersisters have been instantiated.
Type	EntityPersister.getPropertyType(String propertyName) Get the type of a particular property
protected void	AbstractPropertyMapping.initPropertyPaths(String path, Type type, String[] columns, String[] formulaTemplates, Mapping factory)
protected void	AbstractPropertyMapping.initIdentifierPropertyPaths(String path, EntityType etype, String[] columns, Mapping factory)
protected void	AbstractPropertyMapping.initComponentPropertyPaths(String path, AbstractComponentType type, String[] columns, String[] formulaTemplates, Mapping factory)
protected abstract String	AbstractEntityPersister.filterFragment(String alias)
protected void	AbstractEntityPersister.initSubclassPropertyAliasesMap(PersistentClass model) Must be called by subclasses, at the end of their constructors
protected void	AbstractEntityPersister.createUniqueKeyLoaders()
protected void	AbstractEntityPersister.initPropertyPaths(Mapping mapping)
protected UniqueEntityLoader	AbstractEntityPersister.createEntityLoader(LockMode lockMode, Map enabledFilters)
protected UniqueEntityLoader	AbstractEntityPersister.createEntityLoader(LockMode lockMode)
String	AbstractEntityPersister.filterFragment(String alias, Map enabledFilters)
String	AbstractEntityPersister.oneToManyFilterFragment(String alias)
protected void	AbstractEntityPersister.postConstruct(Mapping mapping)
void	AbstractEntityPersister.postInstantiate()
Type	AbstractEntityPersister.getPropertyType(String propertyName)

Uses of MappingException in org.hibernate.property

Methods in org.hibernate.property that throw MappingException

static PropertyAccessor	PropertyAccessorFactory.getPropertyAccessor(Property property, EntityMode mode) Retrieves a PropertyAccessor instance based on the given property definition and entity mode.
static PropertyAccessor	PropertyAccessorFactory.getDynamicMapPropertyAccessor()
static PropertyAccessor	PropertyAccessorFactory.getDom4jPropertyAccessor(String nodeName, Type type, SessionFactoryImplementor factory)
static PropertyAccessor	PropertyAccessorFactory.getPropertyAccessor(Class optionalClass, String type)
static PropertyAccessor	PropertyAccessorFactory.getPropertyAccessor(String type)

Uses of MappingException in org.hibernate.type

Methods in org.hibernate.type that throw MappingException

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[]	Type.sqlTypes(Mapping mapping) Return the SQL type codes for the columns mapped by this type.
int	Type.getColumnSpan(Mapping mapping) How many columns are used to persist this type.
int	SpecialOneToOneType.getColumnSpan(Mapping mapping)
int[]	SpecialOneToOneType.sqlTypes(Mapping mapping)
int	OneToOneType.getColumnSpan(Mapping session)
int[]	OneToOneType.sqlTypes(Mapping session)
int[]	MetaType.sqlTypes(Mapping mapping)
int	MetaType.getColumnSpan(Mapping mapping)
int	ManyToOneType.getColumnSpan(Mapping mapping)
int[]	ManyToOneType.sqlTypes(Mapping mapping)
Joinable	EntityType.getAssociatedJoinable(SessionFactoryImplementor factory)
Type	EntityType.getIdentifierOrUniqueKeyType(Mapping factory)
String	EntityType.getIdentifierOrUniqueKeyPropertyName(Mapping factory)
String	EntityType.getOnCondition(String alias, SessionFactoryImplementor factory, Map enabledFilters)
int	CompositeCustomType.getColumnSpan(Mapping mapping)
int[]	CompositeCustomType.sqlTypes(Mapping mapping)
int[]	ComponentType.sqlTypes(Mapping mapping)
int	ComponentType.getColumnSpan(Mapping mapping)
int[]	CollectionType.sqlTypes(Mapping session)
int	CollectionType.getColumnSpan(Mapping session)
Joinable	CollectionType.getAssociatedJoinable(SessionFactoryImplementor factory)
String	CollectionType.getAssociatedEntityName(SessionFactoryImplementor factory)
Type	CollectionType.getElementType(SessionFactoryImplementor factory) Get the Hibernate type of the collection elements
String	CollectionType.getOnCondition(String alias, SessionFactoryImplementor factory, Map enabledFilters)
int[]	ClobType.sqlTypes(Mapping mapping)
int[]	BlobType.sqlTypes(Mapping mapping)
Joinable	AssociationType.getAssociatedJoinable(SessionFactoryImplementor factory) Get the "persister" for this association - a class or collection persister
String	AssociationType.getAssociatedEntityName(SessionFactoryImplementor factory) Get the entity name of the associated entity
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
int	AnyType.getColumnSpan(Mapping session)
int[]	AnyType.sqlTypes(Mapping mapping)
String	AnyType.getAssociatedEntityName(SessionFactoryImplementor factory)
String	AnyType.getOnCondition(String alias, SessionFactoryImplementor factory, Map enabledFilters)

Constructors in org.hibernate.type that throw MappingException

EmbeddedComponentType(String[] propertyNames, Type[] propertyTypes, boolean[] nullabilities, FetchMode[] joinedFetch, CascadeStyle[] cascade, boolean key, TuplizerLookup tuplizers)

CustomType(Class userTypeClass, Properties parameters)

CompositeCustomType(Class userTypeClass, Properties parameters)

ComponentType(String[] propertyNames, Type[] propertyTypes, boolean[] nullabilities, FetchMode[] joinedFetch, CascadeStyle[] cascade, boolean key, TuplizerLookup tuplizers)

Uses of MappingException in org.hibernate.util

Methods in org.hibernate.util that throw MappingException

static Class	ReflectHelper.reflectedPropertyClass(String className, String name)
static Getter	ReflectHelper.getGetter(Class theClass, String name)