Uses of Class
org.hibernate.MappingException

Packages that use MappingException
org.hibernate   
org.hibernate.cfg   
org.hibernate.dialect   
org.hibernate.engine   
org.hibernate.engine.query   
org.hibernate.hql   
org.hibernate.hql.ast   
org.hibernate.hql.classic   
org.hibernate.id   
org.hibernate.impl   
org.hibernate.loader   
org.hibernate.loader.collection   
org.hibernate.loader.criteria   
org.hibernate.loader.entity   
org.hibernate.mapping   
org.hibernate.persister.collection   
org.hibernate.persister.entity   
org.hibernate.property   
org.hibernate.type   
org.hibernate.util   
 

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
protected  void Configuration.add(org.dom4j.Document doc)
           
 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.addClass(Class persistentClass)
          Read a mapping from an application resource, using a convention.
 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(org.w3c.dom.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
 void Mappings.addQuery(String name, NamedQueryDefinition query)
           
 Configuration Configuration.addResource(String path)
          Read mappings from an application resource trying different classloaders.
 Configuration Configuration.addResource(String path, ClassLoader classLoader)
          Read mappings from an application resource
 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)
          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)
          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 CollectionSecondPass.doSecondPass(Map persistentClasses, Map inheritedMetas)
           
 void NamedSQLQuerySecondPass.doSecondPass(Map persistentClasses, Map inheritedMetas)
           
 void ResultSetMappingSecondPass.doSecondPass(Map persistentClasses, Map inheritedMetas)
           
 void SecondPass.doSecondPass(Map persistentClasses, Map inheritedMetas)
           
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 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.
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 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.
 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, if sequences are supported.
 String Dialect.getSequenceNextValString(String sequenceName)
          Generate the appropriate select statement to to retreive the next value of a sequence, if sequences are supported.
 

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 Assigned.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 ForeignGenerator.configure(Type type, Properties params, Dialect d)
           
 void IncrementGenerator.configure(Type type, Properties params, Dialect dialect)
           
 void MultipleHiLoPerTableGenerator.configure(Type type, Properties params, Dialect dialect)
           
 void SelectGenerator.configure(Type type, Properties params, Dialect d)
           
 void SequenceGenerator.configure(Type type, Properties params, Dialect dialect)
           
 void SequenceHiLoGenerator.configure(Type type, Properties params, Dialect d)
           
 void SequenceIdentityGenerator.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.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 AbstractSessionImpl.getNamedQuery(String queryName)
           
 Query SessionImpl.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()
          Don't bother with the discriminator, unless overridded by subclass
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 PersistentClass.addSubclass(Subclass subclass)
           
 void RootClass.addSubclass(Subclass subclass)
           
protected  void PersistentClass.checkColumnDuplication(Set distinctColumns, Iterator columns)
           
protected  void PersistentClass.checkPropertyColumnDuplication(Set distinctColumns, Iterator properties)
           
 void Collection.createAllKeys()
           
 void Map.createAllKeys()
           
 void ManyToOne.createForeignKey()
           
 void OneToOne.createForeignKey()
           
 void SimpleValue.createForeignKey()
           
abstract  void ToOne.createForeignKey()
           
 void Value.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 Array.getDefaultCollectionType()
           
abstract  CollectionType Collection.getDefaultCollectionType()
           
 CollectionType List.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)
           
 Setter Property.getSetter(Class clazz)
           
 int Column.getSqlTypeCode(Mapping mapping)
           
 Type Any.getType()
           
 Type Collection.getType()
           
 Type Component.getType()
           
 Type DependantValue.getType()
           
 Type ManyToOne.getType()
           
 Type OneToOne.getType()
           
 Type Property.getType()
           
 Type SimpleValue.getType()
           
abstract  Type ToOne.getType()
           
 Type Value.getType()
           
 boolean Collection.isValid(Mapping mapping)
           
 boolean OneToMany.isValid(Mapping mapping)
           
 boolean Property.isValid(Mapping mapping)
           
 boolean SimpleValue.isValid(Mapping mapping)
           
 boolean ToOne.isValid(Mapping mapping)
           
 boolean Value.isValid(Mapping mapping)
           
 void ForeignKey.setReferencedTable(Table referencedTable)
           
 void Any.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 Value.setTypeUsingReflection(String className, String propertyName)
           
 void Collection.validate(Mapping mapping)
           
 void IdentifierCollection.validate(Mapping mapping)
           
 void IndexedCollection.validate(Mapping mapping)
           
 void JoinedSubclass.validate(Mapping mapping)
           
 void PersistentClass.validate(Mapping mapping)
           
 void RootClass.validate(Mapping mapping)
           
 void Set.validate(Mapping mapping)
           
 void SingleTableSubclass.validate(Mapping mapping)
           
 void UnionSubclass.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 abstract  CollectionInitializer AbstractCollectionPersister.createCollectionInitializer(Map enabledFilters)
           
protected  CollectionInitializer BasicCollectionPersister.createCollectionInitializer(Map enabledFilters)
          Create the CollectionLoader
protected  CollectionInitializer OneToManyPersister.createCollectionInitializer(Map enabledFilters)
          Create the OneToManyLoader
protected  String AbstractCollectionPersister.filterFragment(String alias)
           
 String OneToManyPersister.filterFragment(String alias)
           
 String AbstractCollectionPersister.filterFragment(String alias, Map enabledFilters)
           
 String AbstractCollectionPersister.oneToManyFilterFragment(String alias)
           
 void AbstractCollectionPersister.postInstantiate()
           
 void CollectionPersister.postInstantiate()
           
 

Constructors in org.hibernate.persister.collection that throw MappingException
AbstractCollectionPersister(Collection collection, 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
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, once all ClassPersisters have been instantiated.
 

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

Constructors in org.hibernate.type that throw MappingException
ComponentType(String[] propertyNames, Type[] propertyTypes, boolean[] nullabilities, FetchMode[] joinedFetch, CascadeStyle[] cascade, boolean key, TuplizerLookup tuplizers)
           
CompositeCustomType(Class userTypeClass, Properties parameters)
           
CustomType(Class userTypeClass, Properties parameters)
           
EmbeddedComponentType(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 Getter ReflectHelper.getGetter(Class theClass, String name)
           
static Class ReflectHelper.reflectedPropertyClass(String className, String name)