当前页面: 在线文档首页 > Hibernate 3.2.3 正式版 API 英文文档
Uses of Class
Uses of Class org.hibernate.MappingException (Hibernate API Documentation) - Hibernate 3.2.3 正式版 API 英文文档
|
|||||||||||
| 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.addSynchronizedEntityName(String entityName)
Adds an entity name or auto-flush synchronization. |
SQLQuery |
SQLQuery.addSynchronizedEntityClass(Class entityClass)
Adds an entity name or auto-flush synchronization. |
| Uses of MappingException in org.hibernate.cfg |
| Methods in org.hibernate.cfg that throw MappingException | |
void |
SecondPass.doSecondPass(Map persistentClasses)
|
void |
ResultSetMappingSecondPass.doSecondPass(Map persistentClasses)
|
void |
NamedSQLQuerySecondPass.doSecondPass(Map persistentClasses)
|
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,
Map inheritedMetas)
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,
Map inheritedMetas)
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)
Add a cached mapping file. |
Configuration |
Configuration.addCacheableFile(String xmlFile)
Add a cacheable mapping file. |
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 |
Configuration |
Configuration.addInputStream(InputStream xmlInputStream)
Read mappings from an InputStream. |
Configuration |
Configuration.addResource(String resourceName,
ClassLoader classLoader)
Read mappings as a application resource (i.e. |
Configuration |
Configuration.addResource(String resourceName)
Read mappings as a application resourceName (i.e. |
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. |
Configuration |
Configuration.addJar(File jar)
Read all mappings from a jar file Assumes that any file named *.hbm.xml is a mapping document. |
Configuration |
Configuration.addDirectory(File dir)
Read all mapping documents from a directory tree. |
protected void |
Configuration.add(org.dom4j.Document doc)
|
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)
|
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 |
H2Dialect.getCreateSequenceString(String sequenceName)
|
protected String |
H2Dialect.getDropSequenceString(String sequenceName)
|
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 |
protected String |
Dialect.getIdentitySelectString()
Get the select command to use to retrieve the last generated IDENTITY value. |
String |
Dialect.getIdentityColumnString(int type)
The syntax used during DDL to define a column as being an IDENTITY of a particular type. |
protected String |
Dialect.getIdentityColumnString()
The syntax used during DDL to define a column as being an IDENTITY. |
String |
Dialect.getSequenceNextValString(String sequenceName)
Generate the appropriate select statement to to retreive the next value of a sequence. |
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.getCreateSequenceStrings(String sequenceName)
Deprecated. Use Dialect.getCreateSequenceString(String, int, int) instead |
String[] |
Dialect.getCreateSequenceStrings(String sequenceName,
int initialValue,
int incrementSize)
An optional multi-line form for databases which Dialect.supportsPooledSequences(). |
protected String |
Dialect.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.getDropSequenceStrings(String sequenceName)
The multiline script used to drop a sequence. |
protected String |
Dialect.getDropSequenceString(String sequenceName)
Typically dialects which support sequences can drop a sequence with a single command. |
String |
Cache71Dialect.getIdentityColumnString()
|
| 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 withClauseFragment,
String withClauseJoinAlias)
|
| 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 |
SequenceIdentityGenerator.configure(Type type,
Properties params,
Dialect dialect)
|
void |
SequenceHiLoGenerator.configure(Type type,
Properties params,
Dialect d)
|
void |
SequenceGenerator.configure(Type type,
Properties params,
Dialect dialect)
|
void |
SelectGenerator.configure(Type type,
Properties params,
Dialect d)
|
void |
MultipleHiLoPerTableGenerator.configure(Type type,
Properties params,
Dialect dialect)
|
void |
IncrementGenerator.configure(Type type,
Properties params,
Dialect dialect)
|
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.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 | |
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()
|
| 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 |
| 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)
Given a property path, locate the appropriate referenceable property reference. |
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. |
Type |
EntityPersister.getPropertyType(String propertyName)
Get the type of a particular property by name. |
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)
Retrieves the Joinable defining the associated entity. |
String |
EntityType.getOnCondition(String alias,
SessionFactoryImplementor factory,
Map enabledFilters)
|
Type |
EntityType.getIdentifierOrUniqueKeyType(Mapping factory)
Determine the type of either (1) the identifier if we reference the associated entity's PK or (2) the unique key to which we refer (i.e. |
String |
EntityType.getIdentifierOrUniqueKeyPropertyName(Mapping factory)
The name of the property on the associated entity to which our FK refers |
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 | |
CustomType(Class userTypeClass,
Properties parameters)
|
|
CompositeCustomType(Class userTypeClass,
Properties parameters)
|
|
| 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)
|
|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||||