## Uses of Interface
org.hibernate.type.Type

Packages that use Type
org.hibernate: This package defines the central Hibernate APIs.
org.hibernate.cache: This package defines APIs/SPIs and implementations for the Hibernate second-level cache.
org.hibernate.classic: This package implements backward-compatibility with Hibernate 2.1 APIs now deprecated in Hibernate3.
org.hibernate.collection: This package defines a framework for collection wrappers.
org.hibernate.criterion: A framework for defining restriction criteria and order criteria.
org.hibernate.dialect.function: A framework for defining database-specific SQL functions that are available via the dialect.
org.hibernate.ejb
org.hibernate.engine: This package contains classes that are "shared" by other packages, and implementations of some key algorithms.
org.hibernate.engine.query
org.hibernate.engine.query.sql
org.hibernate.envers.entities.mapper.relation.lazy
org.hibernate.event.def: This package defines a default set of event listeners that implements the default behaviors of Hibernate.
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.ast.tree
org.hibernate.hql.ast.util
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.id.factory
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.custom: This package defines a framework for custom loaders that accept handwritten SQL
org.hibernate.loader.entity: This package defines entity loaders
org.hibernate.mapping: This package defines the Hibernate configuration-time metamodel.
org.hibernate.metadata: This package defines an API for accessing the Hibernate runtime metamodel.
org.hibernate.param
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.pretty: Classes for pretty printing things for exception and log messages.
org.hibernate.property: This package abstracts the notion of a "property" of an entity.
org.hibernate.tuple: This package defines a runtime metamodel for entities at the object level and abstracts the differences between the various entity modes.
org.hibernate.tuple.entity
org.hibernate.type: A Hibernate `Type` is a strategy for mapping a Java property type to a JDBC type or types.
org.hibernate.usertype: Interfaces for user-defined custom types.
org.hibernate.util: Utility classes.

Uses of Type in org.hibernate

Methods in org.hibernate that return Type
`Type` `TypeHelper.any(Type metaType, Type identifierType)`
`static Type` `Hibernate.any(Type metaType, Type identifierType)` Deprecated. Use `TypeHelper.any(org.hibernate.type.Type, org.hibernate.type.Type)` instead.
`Type` `TypeHelper.custom(Class userTypeClass)` Retrieve the type for the given user-type class (`UserType` or `CompositeUserType`).
`static Type` `Hibernate.custom(Class userTypeClass)` Deprecated. Use `TypeHelper.custom(java.lang.Class)` instead; see http://opensource.atlassian.com/projects/hibernate/browse/HHH-5182
`Type` `TypeHelper.custom(Class userTypeClass, Properties properties)` Retrieve the type for the given user-type class (`UserType` or `CompositeUserType`).
`static Type` `Hibernate.custom(Class userTypeClass, Properties parameters)` Deprecated. Use `TypeHelper.custom(java.lang.Class)` instead; see http://opensource.atlassian.com/projects/hibernate/browse/HHH-5182
`static Type` `Hibernate.custom(Class userTypeClass, String[] parameterNames, String[] parameterValues)` Deprecated. Use `TypeHelper.custom(java.lang.Class)` instead; see http://opensource.atlassian.com/projects/hibernate/browse/HHH-5182
`Type` `TypeHelper.entity(Class entityClass)` Retrieve a type representing the given entity.
`static Type` `Hibernate.entity(Class persistentClass)` Deprecated. Use `TypeHelper.entity(java.lang.Class)` instead; see http://opensource.atlassian.com/projects/hibernate/browse/HHH-5182
`Type` `TypeHelper.entity(String entityName)` Retrieve a type representing the given entity.
`static Type` `Hibernate.entity(String entityName)` Deprecated. Use `TypeHelper.entity(java.lang.Class)` instead; see http://opensource.atlassian.com/projects/hibernate/browse/HHH-5182
`Type[]` `Query.getReturnTypes()` Return the Hibernate types of the query result set.
`Type` `ScrollableResults.getType(int i)` Get the type of the `i`th column of results
`Type` `TypeHelper.heuristicType(String name)` Uses heuristics to deduce the proper `Type` given a string naming the type or Java class.
`static Type` `Hibernate.serializable(Class serializableClass)` Deprecated. Use `SerializableType.SerializableType(java.lang.Class<T>)` instead.

Methods in org.hibernate with parameters of type Type
`SQLQuery` `SQLQuery.addScalar(String columnAlias, Type type)` Declare a scalar query result.
`Type` `TypeHelper.any(Type metaType, Type identifierType)`
`static Type` `Hibernate.any(Type metaType, Type identifierType)` Deprecated. Use `TypeHelper.any(org.hibernate.type.Type, org.hibernate.type.Type)` instead.
`int[]` `Interceptor.findDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState, String[] propertyNames, Type[] types)` Called from `flush()`.
`int[]` `EmptyInterceptor.findDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState, String[] propertyNames, Type[] types)`
`void` `Interceptor.onDelete(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)` Called before an object is deleted.
`void` `EmptyInterceptor.onDelete(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)`
`boolean` `Interceptor.onFlushDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState, String[] propertyNames, Type[] types)` Called when an object is detected to be dirty, during a flush.
`boolean` `EmptyInterceptor.onFlushDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState, String[] propertyNames, Type[] types)`
`boolean` `Interceptor.onLoad(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)` Called just before an object is initialized.
`boolean` `EmptyInterceptor.onLoad(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)`
`boolean` `Interceptor.onSave(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)` Called before an object is saved.
`boolean` `EmptyInterceptor.onSave(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)`
`Query` `Query.setParameter(int position, Object val, Type type)` Bind a value to a JDBC-style query parameter.
`Query` `Query.setParameter(String name, Object val, Type type)` Bind a value to a named query parameter.
`Query` `Query.setParameterList(String name, Collection vals, Type type)` Bind multiple values to a named query parameter.
`Query` `Query.setParameterList(String name, Object[] vals, Type type)` Bind multiple values to a named query parameter.
`Query` `Query.setParameters(Object[] values, Type[] types)` Bind values and types to positional parameters.

Uses of Type in org.hibernate.cache

Methods in org.hibernate.cache with parameters of type Type
`List` `StandardQueryCache.get(QueryKey key, Type[] returnTypes, boolean isNaturalKeyLookup, Set spaces, SessionImplementor session)`
`List` `QueryCache.get(QueryKey key, Type[] returnTypes, boolean isNaturalKeyLookup, Set spaces, SessionImplementor session)`
`boolean` `StandardQueryCache.put(QueryKey key, Type[] returnTypes, List result, boolean isNaturalKeyLookup, SessionImplementor session)`
`boolean` `QueryCache.put(QueryKey key, Type[] returnTypes, List result, boolean isNaturalKeyLookup, SessionImplementor session)`

Constructors in org.hibernate.cache with parameters of type Type
`CacheKey(Serializable id, Type type, String entityOrRoleName, EntityMode entityMode, SessionFactoryImplementor factory)` Construct a new key for a collection or entity instance.

Uses of Type in org.hibernate.classic

Methods in org.hibernate.classic with parameters of type Type
`int` `Session.delete(String query, Object[] values, Type[] types)` Deprecated. consider using HQL delete statements
`int` `Session.delete(String query, Object value, Type type)` Deprecated. consider using HQL delete statements
`Collection` `Session.filter(Object collection, String filter, Object[] values, Type[] types)` Deprecated. use `Session.createFilter(Object, String)`.setXYZ.`Query.list()`
`Collection` `Session.filter(Object collection, String filter, Object value, Type type)` Deprecated. use `Session.createFilter(Object, String)`.setXYZ.`Query.list()`
`List` `Session.find(String query, Object[] values, Type[] types)` Deprecated. use `Session.createQuery(java.lang.String)`.setXYZ.`Query.list()`
`List` `Session.find(String query, Object value, Type type)` Deprecated. use `Session.createQuery(java.lang.String)`.setXYZ.`Query.list()`
`Iterator` `Session.iterate(String query, Object[] values, Type[] types)` Deprecated. use `Session.createQuery(java.lang.String)`.setXYZ.`Query.iterate()`
`Iterator` `Session.iterate(String query, Object value, Type type)` Deprecated. use `Session.createQuery(java.lang.String)`.setXYZ.`Query.iterate()`

Uses of Type in org.hibernate.collection

Methods in org.hibernate.collection with parameters of type Type
`boolean` `PersistentSet.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentMap.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentList.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentIndexedElementHolder.needsInserting(Object entry, int i, Type elementType)`
`boolean` `PersistentIdentifierBag.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentElementHolder.needsInserting(Object entry, int i, Type elementType)`
`boolean` `PersistentCollection.needsInserting(Object entry, int i, Type elemType)` Do we need to insert this element?
`boolean` `PersistentBag.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentArrayHolder.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentSet.needsUpdating(Object entry, int i, Type elemType)`
`boolean` `PersistentMap.needsUpdating(Object entry, int i, Type elemType)`
`boolean` `PersistentList.needsUpdating(Object entry, int i, Type elemType)`
`boolean` `PersistentIndexedElementHolder.needsUpdating(Object entry, int i, Type elementType)`
`boolean` `PersistentIdentifierBag.needsUpdating(Object entry, int i, Type elemType)`
`boolean` `PersistentElementHolder.needsUpdating(Object entry, int i, Type elementType)`
`boolean` `PersistentCollection.needsUpdating(Object entry, int i, Type elemType)` Do we need to update this element?
`boolean` `PersistentBag.needsUpdating(Object entry, int i, Type elemType)`
`boolean` `PersistentArrayHolder.needsUpdating(Object entry, int i, Type elemType)`

Uses of Type in org.hibernate.criterion

Methods in org.hibernate.criterion that return Type
`Type` `CriteriaQuery.getIdentifierType(Criteria subcriteria)` Get the identifier type of this entity
`Type` `CriteriaQuery.getType(Criteria criteria, String propertyPath)` Get the type of a property path, ignoring projection aliases
`protected Type[]` `SubqueryExpression.getTypes()`
`Type[]` `SQLProjection.getTypes(Criteria crit, CriteriaQuery criteriaQuery)`
`Type[]` `RowCountProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `PropertyProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `ProjectionList.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `Projection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)` Types returned by the rendered SQL `fragment`.
`Type[]` `IdentifierProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `Distinct.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `AliasedProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `AggregateProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)` Types returned by the rendered SQL `fragment`.
`Type[]` `SimpleProjection.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `SQLProjection.getTypes(String alias, Criteria crit, CriteriaQuery criteriaQuery)`
`Type[]` `ProjectionList.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `Projection.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)` Get the return types for a particular user-visible alias.
`Type[]` `Distinct.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `AliasedProjection.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)`
`Type` `CriteriaQuery.getTypeUsingProjection(Criteria criteria, String propertyPath)` Get the type of a property path

Methods in org.hibernate.criterion with parameters of type Type
`protected void` `Example.addPropertyTypedValue(Object value, Type type, List list)`
`boolean` `Example.PropertySelector.include(Object propertyValue, String propertyName, Type type)`
`static Criterion` `Expression.sql(String sql, Object[] values, Type[] types)` Deprecated. use `Restrictions.sqlRestriction(String, Object[], Type[])`
`static Criterion` `Expression.sql(String sql, Object value, Type type)` Deprecated. use `Restrictions.sqlRestriction(String, Object, Type)`
`static Projection` `Projections.sqlGroupProjection(String sql, String groupBy, String[] columnAliases, Type[] types)` A grouping SQL projection, specifying both select clause and group by clause fragments
`static Projection` `Projections.sqlProjection(String sql, String[] columnAliases, Type[] types)` A SQL projection, a typed select clause fragment
`static Criterion` `Restrictions.sqlRestriction(String sql, Object[] values, Type[] types)` Apply a constraint expressed in SQL, with the given JDBC parameters.
`static Criterion` `Restrictions.sqlRestriction(String sql, Object value, Type type)` Apply a constraint expressed in SQL, with the given JDBC parameter.

Constructors in org.hibernate.criterion with parameters of type Type
`SQLCriterion(String sql, Object[] values, Type[] types)`
`SQLProjection(String sql, String[] columnAliases, Type[] types)`
`SQLProjection(String sql, String groupBy, String[] columnAliases, Type[] types)`

Uses of Type in org.hibernate.dialect.function

Methods in org.hibernate.dialect.function that return Type
`Type` `VarArgsSQLFunction.getReturnType(Type firstArgumentType, Mapping mapping)` The return type of the function.
`Type` `TrimFunctionTemplate.getReturnType(Type firstArgument, Mapping mapping)`
`Type` `StandardSQLFunction.getReturnType(Type firstArgumentType, Mapping mapping)` The return type of the function.
`Type` `StandardAnsiSqlAggregationFunctions.SumFunction.getReturnType(Type firstArgumentType, Mapping mapping)`
`Type` `SQLFunctionTemplate.getReturnType(Type argumentType, Mapping mapping)` The return type of the function.
`Type` `SQLFunction.getReturnType(Type firstArgumentType, Mapping mapping)` The return type of the function.
`Type` `PositionSubstringFunction.getReturnType(Type firstArgumentType, Mapping mapping)`
`Type` `NvlFunction.getReturnType(Type argumentType, Mapping mapping)`
`Type` `NoArgSQLFunction.getReturnType(Type argumentType, Mapping mapping)`
`Type` `DerbyConcatFunction.getReturnType(Type argumentType, Mapping mapping)` The return type of the function.
`Type` `ConvertFunction.getReturnType(Type firstArgumentType, Mapping mapping)`
`Type` `ClassicCountFunction.getReturnType(Type columnType, Mapping mapping)`
`Type` `ClassicAvgFunction.getReturnType(Type columnType, Mapping mapping)`
`Type` `CharIndexFunction.getReturnType(Type columnType, Mapping mapping)`
`Type` `CastFunction.getReturnType(Type columnType, Mapping mapping)`
`Type` `AbstractAnsiTrimEmulationFunction.getReturnType(Type argumentType, Mapping mapping)` The return type of the function.
`Type` `StandardSQLFunction.getType()` Function static return type accessor.

Methods in org.hibernate.dialect.function with parameters of type Type
`protected int` `StandardAnsiSqlAggregationFunctions.SumFunction.determineJdbcTypeCode(Type type, Mapping mapping)`
`protected int` `StandardAnsiSqlAggregationFunctions.AvgFunction.determineJdbcTypeCode(Type firstArgumentType, SessionFactoryImplementor factory)`
`Type` `VarArgsSQLFunction.getReturnType(Type firstArgumentType, Mapping mapping)` The return type of the function.
`Type` `TrimFunctionTemplate.getReturnType(Type firstArgument, Mapping mapping)`
`Type` `StandardSQLFunction.getReturnType(Type firstArgumentType, Mapping mapping)` The return type of the function.
`Type` `StandardAnsiSqlAggregationFunctions.SumFunction.getReturnType(Type firstArgumentType, Mapping mapping)`
`Type` `SQLFunctionTemplate.getReturnType(Type argumentType, Mapping mapping)` The return type of the function.
`Type` `SQLFunction.getReturnType(Type firstArgumentType, Mapping mapping)` The return type of the function.
`Type` `PositionSubstringFunction.getReturnType(Type firstArgumentType, Mapping mapping)`
`Type` `NvlFunction.getReturnType(Type argumentType, Mapping mapping)`
`Type` `NoArgSQLFunction.getReturnType(Type argumentType, Mapping mapping)`
`Type` `DerbyConcatFunction.getReturnType(Type argumentType, Mapping mapping)` The return type of the function.
`Type` `ConvertFunction.getReturnType(Type firstArgumentType, Mapping mapping)`
`Type` `ClassicCountFunction.getReturnType(Type columnType, Mapping mapping)`
`Type` `ClassicAvgFunction.getReturnType(Type columnType, Mapping mapping)`
`Type` `CharIndexFunction.getReturnType(Type columnType, Mapping mapping)`
`Type` `CastFunction.getReturnType(Type columnType, Mapping mapping)`
`Type` `AbstractAnsiTrimEmulationFunction.getReturnType(Type argumentType, Mapping mapping)` The return type of the function.
`String` `VarArgsSQLFunction.render(Type firstArgumentType, List arguments, SessionFactoryImplementor factory)`
`String` `TrimFunctionTemplate.render(Type firstArgument, List args, SessionFactoryImplementor factory)`
`String` `StandardSQLFunction.render(Type firstArgumentType, List arguments, SessionFactoryImplementor sessionFactory)` Render the function call as SQL fragment.
`String` `StandardJDBCEscapeFunction.render(Type argumentType, List args, SessionFactoryImplementor factory)`
`String` `StandardAnsiSqlAggregationFunctions.CountFunction.render(Type firstArgumentType, List arguments, SessionFactoryImplementor factory)`
`String` `StandardAnsiSqlAggregationFunctions.AvgFunction.render(Type firstArgumentType, List arguments, SessionFactoryImplementor factory)`
`String` `SQLFunctionTemplate.render(Type argumentType, List args, SessionFactoryImplementor factory)` Render the function call as SQL fragment.
`String` `SQLFunction.render(Type firstArgumentType, List arguments, SessionFactoryImplementor factory)` Render the function call as SQL fragment.
`String` `PositionSubstringFunction.render(Type firstArgumentType, List args, SessionFactoryImplementor factory)`
`String` `NvlFunction.render(Type argumentType, List args, SessionFactoryImplementor factory)`
`String` `NoArgSQLFunction.render(Type argumentType, List args, SessionFactoryImplementor factory)`
`String` `DerbyConcatFunction.render(Type argumentType, List args, SessionFactoryImplementor factory)` Render the function call as SQL fragment.
`String` `ConvertFunction.render(Type firstArgumentType, List args, SessionFactoryImplementor factory)`
`String` `CharIndexFunction.render(Type columnType, List args, SessionFactoryImplementor factory)`
`String` `CastFunction.render(Type columnType, List args, SessionFactoryImplementor factory)`
`String` `AbstractAnsiTrimEmulationFunction.render(Type argumentType, List args, SessionFactoryImplementor factory)` Render the function call as SQL fragment.

Constructors in org.hibernate.dialect.function with parameters of type Type
`ConditionalParenthesisFunction(String name, Type type)`
`NoArgSQLFunction(String name, Type returnType)`
`NoArgSQLFunction(String name, Type returnType, boolean hasParenthesesIfNoArguments)`
`SQLFunctionTemplate(Type type, String template)`
`SQLFunctionTemplate(Type type, String template, boolean hasParenthesesIfNoArgs)`
`StandardJDBCEscapeFunction(String name, Type typeValue)`
`StandardSQLFunction(String name, Type registeredType)` Construct a standard SQL function definition with a static return type.
`VarArgsSQLFunction(Type registeredType, String begin, String sep, String end)` Constructs a VarArgsSQLFunction instance with a 'static' return type.

Uses of Type in org.hibernate.ejb

Methods in org.hibernate.ejb that return Type
`Type` `AbstractEntityManagerImpl.TupleBuilderTransformer.HqlTupleElementImpl.getHibernateType()`

Methods in org.hibernate.ejb with parameters of type Type
`void` `HibernateEntityManagerImplementor.Options.ResultMetadataValidator.validate(Type[] returnTypes)`

Constructors in org.hibernate.ejb with parameters of type Type
`AbstractEntityManagerImpl.TupleBuilderTransformer.HqlTupleElementImpl(int position, String alias, Type hibernateType)`

Uses of Type in org.hibernate.engine

Methods in org.hibernate.engine that return Type
`Type[]` `QueryParameters.getFilteredPositionalParameterTypes()`
`Type` `SessionImplementor.getFilterParameterType(String filterParameterName)` Deprecated. use #getLoadQueryInfluencers instead
`Type` `LoadQueryInfluencers.getFilterParameterType(String filterParameterName)`
`Type` `Mapping.getIdentifierType(String className)`
`Type` `FilterDefinition.getParameterType(String parameterName)` Retreive the type of the named parameter defined for this filter.
`Type[]` `QueryParameters.getPositionalParameterTypes()`
`Type` `Mapping.getReferencedPropertyType(String className, String propertyName)`
`Type[]` `SessionFactoryImplementor.getReturnTypes(String queryString)` Get the return types of a query
`Type` `TypedValue.getType()`

Methods in org.hibernate.engine with parameters of type Type
`static int` `ParameterBinder.bindPositionalParameters(PreparedStatement st, Object[] values, Type[] types, int start, SessionImplementor session)`
`static IdentifierValue` `UnsavedValueFactory.getUnsavedIdentifierValue(String unsavedValue, Getter identifierGetter, Type identifierType, Constructor constructor)` Return an IdentifierValue for the specified unsaved-value.
`void` `ForeignKeys.Nullifier.nullifyTransientReferences(Object[] values, Type[] types)` Nullify all references to entities that have not yet been inserted in the database, where the foreign key points toward that entity
`void` `QueryParameters.setPositionalParameterTypes(Type[] types)`

Constructors in org.hibernate.engine with parameters of type Type
`EntityUniqueKey(String entityName, String uniqueKeyName, Object semiResolvedKey, Type keyType, EntityMode entityMode, SessionFactoryImplementor factory)`
`QueryParameters(Type[] positionalParameterTypes, Object[] postionalParameterValues)`
`QueryParameters(Type[] positionalParameterTypes, Object[] positionalParameterValues, LockOptions lockOptions, RowSelection rowSelection, boolean isReadOnlyInitialized, boolean readOnly, boolean cacheable, String cacheRegion, String comment, boolean isLookupByNaturalKey, ResultTransformer transformer)`
`QueryParameters(Type[] positionalParameterTypes, Object[] positionalParameterValues, Map namedParameters, LockOptions lockOptions, RowSelection rowSelection, boolean isReadOnlyInitialized, boolean readOnly, boolean cacheable, String cacheRegion, String comment, Serializable[] collectionKeys, Object optionalObject, String optionalEntityName, Serializable optionalId, ResultTransformer transformer)`
`QueryParameters(Type[] positionalParameterTypes, Object[] positionalParameterValues, Map namedParameters, LockOptions lockOptions, RowSelection rowSelection, boolean isReadOnlyInitialized, boolean readOnly, boolean cacheable, String cacheRegion, String comment, Serializable[] collectionKeys, ResultTransformer transformer)`
`QueryParameters(Type[] positionalParameterTypes, Object[] postionalParameterValues, Map namedParameters, Serializable[] collectionKeys)`
`QueryParameters(Type[] positionalParameterTypes, Object[] postionalParameterValues, Object optionalObject, String optionalEntityName, Serializable optionalObjectId)`
`QueryParameters(Type[] positionalParameterTypes, Object[] postionalParameterValues, Serializable[] collectionKeys)`
`QueryParameters(Type type, Object value)`
`TypedValue(Type type, Object value, EntityMode entityMode)`

Uses of Type in org.hibernate.engine.query

Methods in org.hibernate.engine.query that return Type
`Type` `OrdinalParameterDescriptor.getExpectedType()`
`Type` `NamedParameterDescriptor.getExpectedType()`
`Type` `ParameterMetadata.getNamedParameterExpectedType(String name)`
`Type` `ParameterMetadata.getOrdinalParameterExpectedType(int position)`
`Type[]` `ReturnMetadata.getReturnTypes()`
`Type[]` `QueryMetadata.getReturnTypes()` An array of types describing the returns of the source query.

Methods in org.hibernate.engine.query with parameters of type Type
`void` `NamedParameterDescriptor.resetExpectedType(Type type)`

Constructors in org.hibernate.engine.query with parameters of type Type
`NamedParameterDescriptor(String name, Type expectedType, int[] sourceLocations, boolean jpaStyle)`
`OrdinalParameterDescriptor(int ordinalPosition, Type expectedType, int sourceLocation)`
`QueryMetadata(String sourceQuery, ParameterMetadata parameterMetadata, String[] returnAliases, Type[] returnTypes, Set querySpaces)`
`ReturnMetadata(String[] returnAliases, Type[] returnTypes)`

Uses of Type in org.hibernate.engine.query.sql

Methods in org.hibernate.engine.query.sql that return Type
`Type` `NativeSQLQueryScalarReturn.getType()`

Constructors in org.hibernate.engine.query.sql with parameters of type Type
`NativeSQLQueryScalarReturn(String alias, Type type)`

Uses of Type in org.hibernate.envers.entities.mapper.relation.lazy

Methods in org.hibernate.envers.entities.mapper.relation.lazy that return Type
`Type` `AbstractDelegateSessionImplementor.getFilterParameterType(String filterParameterName)`

Uses of Type in org.hibernate.event.def

Methods in org.hibernate.event.def with parameters of type Type
`void` `AbstractVisitor.processEntityPropertyValues(Object[] values, Type[] types)` Dispatch each property value to processValue().
`protected boolean` `DefaultReplicateEventListener.visitCollectionsBeforeSave(Object entity, Serializable id, Object[] values, Type[] types, EventSource source)`
`protected boolean` `AbstractSaveEventListener.visitCollectionsBeforeSave(Object entity, Serializable id, Object[] values, Type[] types, EventSource source)`

Uses of Type in org.hibernate.hql

Methods in org.hibernate.hql that return Type
`Type` `ParameterTranslations.getNamedParameterExpectedType(String name)`
`Type` `ParameterTranslations.getOrdinalParameterExpectedType(int ordinalPosition)`
`Type[]` `QueryTranslator.getReturnTypes()` Returns an array of Types represented in the query result.

Methods in org.hibernate.hql with parameters of type Type
`static String[][]` `NameGenerator.generateColumnNames(Type[] types, SessionFactoryImplementor f)`

Uses of Type in org.hibernate.hql.ast

Methods in org.hibernate.hql.ast that return Type
`Type` `ParameterTranslationsImpl.ParameterInfo.getExpectedType()`
`Type` `ParameterTranslationsImpl.getNamedParameterExpectedType(String name)`
`Type` `ParameterTranslationsImpl.getOrdinalParameterExpectedType(int ordinalPosition)`
`Type` `TypeDiscriminatorMetadata.getResolutionType()` Get the type used to resolve the actual discriminator value resulting from `TypeDiscriminatorMetadata.getSqlFragment()` back into a `Class` reference.
`Type[]` `QueryTranslatorImpl.getReturnTypes()` Types of the return values of an `iterate()` style query.
`Type[]` `HqlSqlWalker.getReturnTypes()`

Constructors in org.hibernate.hql.ast with parameters of type Type
`ParameterTranslationsImpl.ParameterInfo(int[] sqlPositions, Type expectedType)`
`ParameterTranslationsImpl.ParameterInfo(int sqlPosition, Type expectedType)`

Uses of Type in org.hibernate.hql.ast.tree

Methods in org.hibernate.hql.ast.tree that return Type
`protected Type` `BinaryLogicOperatorNode.extractDataType(Node operand)`
`Type` `UnaryLogicOperatorNode.getDataType()`
`Type` `UnaryArithmeticNode.getDataType()`
`Type` `SqlNode.getDataType()`
`Type` `SelectExpression.getDataType()` Returns the data type of the select expression.
`Type` `QueryNode.getDataType()`
`Type` `OperatorNode.getDataType()` Retrieves the data type for the overall operator expression.
`Type` `LiteralNode.getDataType()`
`Type` `IdentNode.getDataType()`
`Type` `FromElement.getDataType()`
`Type` `DotNode.getDataType()`
`Type` `CountNode.getDataType()`
`Type` `ConstructorNode.getDataType()` Deprecated. (tell clover to ignore this method)
`Type` `ComponentJoin.getDataType()`
`Type` `ComponentJoin.ComponentFromElementType.getDataType()`
`Type` `CaseNode.getDataType()`
`Type` `Case2Node.getDataType()`
`Type` `BooleanLiteralNode.getDataType()`
`Type` `BinaryLogicOperatorNode.getDataType()`
`Type` `BinaryArithmeticOperatorNode.getDataType()` Figure out the type of the binary expression by looking at the types of the operands.
`Type` `BetweenOperatorNode.getDataType()`
`Type` `AggregateNode.getDataType()`
`Type` `ParameterNode.getExpectedType()`
`Type` `JavaConstantNode.getExpectedType()`
`Type` `ExpectedTypeAwareNode.getExpectedType()`
`Type` `BooleanLiteralNode.getExpectedType()`
`Type` `MethodNode.getFirstArgumentType()`
`Type` `FunctionNode.getFirstArgumentType()`
`Type` `AggregateNode.getFirstArgumentType()`
`Type[]` `IntoClause.getInsertionTypes()`
`Type` `FromElement.getPropertyType(String propertyName, String propertyPath)`
`Type` `ComponentJoin.ComponentFromElementType.getPropertyType(String propertyName, String propertyPath)` Returns the type of a property, given it's name (the last part) and the full path.
`Type[]` `SelectClause.getQueryReturnTypes()` The types actually being returned from this query at the "object level".
`Type` `FromElement.getSelectType()`
`protected Type` `MapValueNode.resolveType(QueryableCollection collectionPersister)`
`protected Type` `MapKeyNode.resolveType(QueryableCollection collectionPersister)`
`protected Type` `MapEntryNode.resolveType(QueryableCollection collectionPersister)`
`protected abstract Type` `AbstractMapComponentNode.resolveType(QueryableCollection collectionPersister)`

Methods in org.hibernate.hql.ast.tree with parameters of type Type
`void` `FromElement.handlePropertyBeingDereferenced(Type propertySource, String propertyName)`
`protected void` `BinaryLogicOperatorNode.mutateRowValueConstructorSyntaxesIfNecessary(Type lhsType, Type rhsType)`
`void` `SqlNode.setDataType(Type dataType)`
`void` `ParameterNode.setExpectedType(Type expectedType)`
`void` `JavaConstantNode.setExpectedType(Type expectedType)`
`void` `ExpectedTypeAwareNode.setExpectedType(Type expectedType)`
`void` `BooleanLiteralNode.setExpectedType(Type expectedType)`

Uses of Type in org.hibernate.hql.ast.util

Methods in org.hibernate.hql.ast.util that return Type
`Type` `SessionFactoryHelper.findFunctionReturnType(String functionName, antlr.collections.AST first)` Find the function return type given the function name and the first argument expression node.
`Type` `SessionFactoryHelper.findFunctionReturnType(String functionName, SQLFunction sqlFunction, antlr.collections.AST firstArgument)`

Methods in org.hibernate.hql.ast.util with parameters of type Type
`String[][]` `SessionFactoryHelper.generateColumnNames(Type[] sqlResultTypes)`
`int` `SessionFactoryHelper.getColumnSpan(Type type)` Retrieve the number of columns represented by this type.

Uses of Type in org.hibernate.hql.classic

Methods in org.hibernate.hql.classic that return Type
`Type` `SelectParser.aggregateType(List funcTokenList, Type type, QueryTranslatorImpl q)`
`protected Type` `PathExpressionParser.getPropertyType()`
`Type[]` `QueryTranslatorImpl.getReturnTypes()` Types of the return values of an `iterate()` style query.
`Type` `PathExpressionParser.getWhereColumnType()`

Methods in org.hibernate.hql.classic with parameters of type Type
`Type` `SelectParser.aggregateType(List funcTokenList, Type type, QueryTranslatorImpl q)`

Uses of Type in org.hibernate.id

Methods in org.hibernate.id that return Type
`protected Type` `SequenceGenerator.getIdentifierType()`

Methods in org.hibernate.id with parameters of type Type
`void` `UUIDHexGenerator.configure(Type type, Properties params, Dialect d)` Configure this instance, given the value of parameters specified by the user as `<param>` elements.
`void` `UUIDGenerator.configure(Type type, Properties params, Dialect d)`
`void` `TableHiLoGenerator.configure(Type type, Properties params, Dialect d)`
`void` `TableGenerator.configure(Type type, Properties params, Dialect dialect)`
`void` `SequenceIdentityGenerator.configure(Type type, Properties params, Dialect dialect)`
`void` `SequenceHiLoGenerator.configure(Type type, Properties params, Dialect d)`
`void` `SequenceGenerator.configure(Type type, Properties params, Dialect dialect)`
`void` `SelectGenerator.configure(Type type, Properties params, Dialect d)`
`void` `MultipleHiLoPerTableGenerator.configure(Type type, Properties params, Dialect dialect)`
`void` `IncrementGenerator.configure(Type type, Properties params, Dialect dialect)`
`void` `ForeignGenerator.configure(Type type, Properties params, Dialect d)` Configure this instance, given the value of parameters specified by the user as `<param>` elements.
`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)`
`static Serializable` `IdentifierGeneratorHelper.get(ResultSet rs, String identifierColumnName, Type type)` Extract the value from the result set (which is assumed to already have been positioned to the apopriate row) and wrp it in the appropriate Java numeric type.
`static Serializable` `IdentifierGeneratorHelper.getGeneratedIdentity(ResultSet rs, String identifierColumnName, Type type)` Get the generated identifier when using identity columns

Uses of Type in org.hibernate.id.enhanced

Methods in org.hibernate.id.enhanced that return Type
`Type` `TableGenerator.getIdentifierType()` Type mapping for the identifier.
`Type` `SequenceStyleGenerator.getIdentifierType()` Getter for property 'identifierType'.

Methods in org.hibernate.id.enhanced with parameters of type Type
`protected DatabaseStructure` `SequenceStyleGenerator.buildDatabaseStructure(Type type, Properties params, Dialect dialect, boolean forceTableUse, String sequenceName, int initialValue, int incrementSize)` Build the database structure.
`void` `TableGenerator.configure(Type type, Properties params, Dialect dialect)` Configure this instance, given the value of parameters specified by the user as `<param>` elements.
`void` `SequenceStyleGenerator.configure(Type type, Properties params, Dialect dialect)` Configure this instance, given the value of parameters specified by the user as `<param>` elements.

Uses of Type in org.hibernate.id.factory

Methods in org.hibernate.id.factory with parameters of type Type
`IdentifierGenerator` `IdentifierGeneratorFactory.createIdentifierGenerator(String strategy, Type type, Properties config)` Given a strategy, retrieve the appropriate identifier generator instance.
`IdentifierGenerator` `DefaultIdentifierGeneratorFactory.createIdentifierGenerator(String strategy, Type type, Properties config)` Given a strategy, retrieve the appropriate identifier generator instance.

Uses of Type in org.hibernate.impl

Methods in org.hibernate.impl that return Type
`Type` `TypeLocatorImpl.any(Type metaType, Type identifierType)`
`Type` `TypeLocatorImpl.custom(Class userTypeClass)` Retrieve the type for the given user-type class (`UserType` or `CompositeUserType`).
`Type` `TypeLocatorImpl.custom(Class userTypeClass, Properties parameters)` Retrieve the type for the given user-type class (`UserType` or `CompositeUserType`).
`protected Type` `AbstractQueryImpl.determineType(int paramPosition, Object paramValue)`
`protected Type` `AbstractQueryImpl.determineType(int paramPosition, Object paramValue, Type defaultType)`
`protected Type` `AbstractQueryImpl.determineType(String paramName, Class clazz)`
`protected Type` `AbstractQueryImpl.determineType(String paramName, Object paramValue)`
`protected Type` `AbstractQueryImpl.determineType(String paramName, Object paramValue, Type defaultType)`
`Type` `TypeLocatorImpl.entity(Class entityClass)` Retrieve a type representing the given entity.
`Type` `TypeLocatorImpl.entity(String entityName)` Retrieve a type representing the given entity.
`Type` `StatelessSessionImpl.getFilterParameterType(String filterParameterName)`
`Type` `SessionImpl.getFilterParameterType(String filterParameterName)` Retreive the type for a given filter parrameter.
`Type` `SessionFactoryImpl.getIdentifierType(String className)`
`Type` `SessionFactoryImpl.getReferencedPropertyType(String className, String propertyName)`
`Type[]` `SQLQueryImpl.getReturnTypes()`
`Type[]` `AbstractQueryImpl.getReturnTypes()`
`Type[]` `SessionFactoryImpl.getReturnTypes(String queryString)`
`Type` `AbstractScrollableResults.getType(int i)`
`protected Type[]` `AbstractScrollableResults.getTypes()`
`Type` `TypeLocatorImpl.heuristicType(String name)` Uses heuristics to deduce the proper `Type` given a string naming the type or Java class.
`Type[]` `CollectionFilterImpl.typeArray()`
`Type[]` `AbstractQueryImpl.typeArray()`

Methods in org.hibernate.impl with parameters of type Type
`SQLQuery` `SQLQueryImpl.addScalar(String columnAlias, Type type)`
`Type` `TypeLocatorImpl.any(Type metaType, Type identifierType)`
`int` `SessionImpl.delete(String query, Object[] values, Type[] types)`
`int` `SessionImpl.delete(String query, Object value, Type type)`
`protected Type` `AbstractQueryImpl.determineType(int paramPosition, Object paramValue, Type defaultType)`
`protected Type` `AbstractQueryImpl.determineType(String paramName, Object paramValue, Type defaultType)`
`Collection` `SessionImpl.filter(Object collection, String filter, Object[] values, Type[] types)`
`Collection` `SessionImpl.filter(Object collection, String filter, Object value, Type type)`
`List` `SessionImpl.find(String query, Object[] values, Type[] types)`
`List` `SessionImpl.find(String query, Object value, Type type)`
`protected Object` `AbstractScrollableResults.getFinal(int col, Type returnType)` Check that the requested type is compatible with the result type, and return the column value.
`protected Object` `AbstractScrollableResults.getNonFinal(int col, Type returnType)` Check that the requested type is compatible with the result type, and return the column value.
`Iterator` `SessionImpl.iterate(String query, Object[] values, Type[] types)`
`Iterator` `SessionImpl.iterate(String query, Object value, Type type)`
`Query` `AbstractQueryImpl.setParameter(int position, Object val, Type type)`
`Query` `AbstractQueryImpl.setParameter(String name, Object val, Type type)`
`Query` `AbstractQueryImpl.setParameterList(String name, Collection vals, Type type)`
`Query` `AbstractQueryImpl.setParameterList(String name, Object[] vals, Type type)`
`Query` `AbstractQueryImpl.setParameters(Object[] values, Type[] types)`

Constructors in org.hibernate.impl with parameters of type Type
`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)`
`IteratorImpl(ResultSet rs, PreparedStatement ps, EventSource sess, boolean readOnly, Type[] types, String[][] columnNames, HolderInstantiator holderInstantiator)`
`ScrollableResultsImpl(ResultSet rs, PreparedStatement ps, SessionImplementor sess, Loader loader, QueryParameters queryParameters, Type[] types, HolderInstantiator holderInstantiator)`

Uses of Type in org.hibernate.loader

Methods in org.hibernate.loader with parameters of type Type
`protected List` `Loader.list(SessionImplementor session, QueryParameters queryParameters, Set querySpaces, Type[] resultTypes)` Return the query results, using the query cache, called by subclasses that implement cacheable queries
`void` `Loader.loadCollection(SessionImplementor session, Serializable id, Type type)` Called by subclasses that initialize collections
`void` `Loader.loadCollectionBatch(SessionImplementor session, Serializable[] ids, Type type)` Called by wrappers that batch initialize collections
`protected void` `Loader.loadCollectionSubselect(SessionImplementor session, Serializable[] ids, Object[] parameterValues, Type[] parameterTypes, Map namedParameters, Type type)` Called by subclasses that batch initialize collections
`protected void` `Loader.loadCollectionSubselect(SessionImplementor session, Serializable[] ids, Object[] parameterValues, Type[] parameterTypes, Map namedParameters, Type type)` Called by subclasses that batch initialize collections
`protected List` `Loader.loadEntity(SessionImplementor session, Object key, Object index, Type keyType, Type indexType, EntityPersister persister)` Called by subclasses that load entities
`protected List` `Loader.loadEntity(SessionImplementor session, Object id, Type identifierType, Object optionalObject, String optionalEntityName, Serializable optionalIdentifier, EntityPersister persister, LockOptions lockOptions)` Called by subclasses that load entities
`List` `Loader.loadEntityBatch(SessionImplementor session, Serializable[] ids, Type idType, Object optionalObject, String optionalEntityName, Serializable optionalId, EntityPersister persister, LockOptions lockOptions)` Called by wrappers that batch load entities
`protected ScrollableResults` `Loader.scroll(QueryParameters queryParameters, Type[] returnTypes, HolderInstantiator holderInstantiator, SessionImplementor session)` Return the query results, as an instance of `ScrollableResults`

Uses of Type in org.hibernate.loader.collection

Methods in org.hibernate.loader.collection that return Type
`protected Type` `CollectionLoader.getKeyType()`

Uses of Type in org.hibernate.loader.criteria

Methods in org.hibernate.loader.criteria that return Type
`Type` `CriteriaQueryTranslator.getIdentifierType(Criteria subcriteria)`
`Type[]` `CriteriaQueryTranslator.getProjectedTypes()`
`Type[]` `CriteriaJoinWalker.getResultTypes()`
`Type` `CriteriaQueryTranslator.getType(Criteria subcriteria, String propertyName)`
`Type` `CriteriaQueryTranslator.getTypeUsingProjection(Criteria subcriteria, String propertyName)`

Uses of Type in org.hibernate.loader.custom

Methods in org.hibernate.loader.custom that return Type
`Type` `ScalarReturn.getType()`

Constructors in org.hibernate.loader.custom with parameters of type Type
`CustomLoader.ScalarResultColumnProcessor(String alias, Type type)`
`ScalarReturn(Type type, String columnAlias)`

Uses of Type in org.hibernate.loader.entity

Fields in org.hibernate.loader.entity declared as Type
`protected Type` `AbstractEntityLoader.uniqueKeyType`

Constructors in org.hibernate.loader.entity with parameters of type Type
`AbstractEntityLoader(OuterJoinLoadable persister, Type uniqueKeyType, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)`
`EntityLoader(OuterJoinLoadable persister, String[] uniqueKey, Type uniqueKeyType, int batchSize, LockMode lockMode, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)`
`EntityLoader(OuterJoinLoadable persister, String[] uniqueKey, Type uniqueKeyType, int batchSize, LockOptions lockOptions, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)`

Uses of Type in org.hibernate.mapping

Methods in org.hibernate.mapping that return Type
`Type` `Value.getType()`
`abstract Type` `ToOne.getType()`
`Type` `SimpleValue.getType()`
`Type` `Property.getType()`
`Type` `OneToOne.getType()`
`Type` `OneToMany.getType()`
`Type` `ManyToOne.getType()`
`Type` `DependantValue.getType()`
`Type` `Component.getType()`
`Type` `Collection.getType()`
`Type` `Any.getType()`

Uses of Type in org.hibernate.metadata

Methods in org.hibernate.metadata that return Type
`Type` `CollectionMetadata.getElementType()` The collection element type
`Type` `ClassMetadata.getIdentifierType()` Get the identifier Hibernate type
`Type` `CollectionMetadata.getIndexType()` The collection index type (or null if the collection has no index)
`Type` `CollectionMetadata.getKeyType()` The collection key type
`Type` `ClassMetadata.getPropertyType(String propertyName)` Get the type of a particular (named) property
`Type[]` `ClassMetadata.getPropertyTypes()` Get the Hibernate types of the class properties

Uses of Type in org.hibernate.param

Methods in org.hibernate.param that return Type
`Type` `VersionTypeSeedParameterSpecification.getExpectedType()` Get the type which we are expeting for a bind into this parameter based on translated contextual information.
`Type` `ParameterSpecification.getExpectedType()` Get the type which we are expeting for a bind into this parameter based on translated contextual information.
`Type` `DynamicFilterParameterSpecification.getExpectedType()` Get the type which we are expeting for a bind into this parameter based on translated contextual information.
`Type` `CollectionFilterKeyParameterSpecification.getExpectedType()` Get the type which we are expeting for a bind into this parameter based on translated contextual information.
`Type` `AbstractExplicitParameterSpecification.getExpectedType()` Get the type which we are expeting for a bind into this parameter based on translated contextual information.

Methods in org.hibernate.param with parameters of type Type
`void` `VersionTypeSeedParameterSpecification.setExpectedType(Type expectedType)` Injects the expected type.
`void` `ParameterSpecification.setExpectedType(Type expectedType)` Injects the expected type.
`void` `DynamicFilterParameterSpecification.setExpectedType(Type expectedType)` Injects the expected type.
`void` `CollectionFilterKeyParameterSpecification.setExpectedType(Type expectedType)` Injects the expected type.
`void` `AbstractExplicitParameterSpecification.setExpectedType(Type expectedType)` Injects the expected type.

Constructors in org.hibernate.param with parameters of type Type
`CollectionFilterKeyParameterSpecification(String collectionRole, Type keyType, int queryParameterPosition)` Creates a specialized collection-filter collection-key parameter spec.
`DynamicFilterParameterSpecification(String filterName, String parameterName, Type definedParameterType)` Constructs a parameter specification for a particular filter parameter.

Uses of Type in org.hibernate.persister.collection

Fields in org.hibernate.persister.collection declared as Type
`protected Type` `AbstractCollectionPersister.elementType`

Methods in org.hibernate.persister.collection that return Type
`Type` `CollectionPersister.getElementType()` Get the "element" type
`Type` `AbstractCollectionPersister.getElementType()`
`Type` `CollectionPersister.getIdentifierType()` Get the type of the surrogate key
`Type` `AbstractCollectionPersister.getIdentifierType()`
`Type` `CollectionPersister.getIndexType()` Get the "index" type for a list or map (optional operation)
`Type` `AbstractCollectionPersister.getIndexType()`
`Type` `CollectionPersister.getKeyType()` Get the "key" type (the type of the foreign key)
`Type` `AbstractCollectionPersister.getKeyType()`
`Type` `ElementPropertyMapping.getType()`
`Type` `CompositeElementPropertyMapping.getType()`
`Type` `CollectionPropertyMapping.getType()`
`Type` `AbstractCollectionPersister.getType()`
`Type` `ElementPropertyMapping.toType(String propertyName)`
`Type` `CollectionPropertyMapping.toType(String propertyName)`
`Type` `AbstractCollectionPersister.toType(String propertyName)`

Constructors in org.hibernate.persister.collection with parameters of type Type
`ElementPropertyMapping(String[] elementColumns, Type type)`

Uses of Type in org.hibernate.persister.entity

Classes in org.hibernate.persister.entity that implement Type
`class` `DiscriminatorType` TODO : javadoc

Methods in org.hibernate.persister.entity that return Type
`Type` `UnionSubclassEntityPersister.getDiscriminatorType()`
`Type` `SingleTableEntityPersister.getDiscriminatorType()`
`Type` `Loadable.getDiscriminatorType()` Get the discriminator type
`Type` `JoinedSubclassEntityPersister.getDiscriminatorType()`
`Type` `EntityPersister.getIdentifierType()` Get the identifier type
`Type` `AbstractEntityPersister.getIdentifierType()`
`Type` `EntityPersister.getPropertyType(String propertyName)` Get the type of a particular property by name.
`Type` `AbstractEntityPersister.getPropertyType(String propertyName)`
`Type[]` `EntityPersister.getPropertyTypes()` Get the Hibernate types of the class properties
`Type[]` `AbstractEntityPersister.getPropertyTypes()`
`Type` `DiscriminatorMetadata.getResolutionType()` Get the type used to resolve the actual discriminator value resulting from `DiscriminatorMetadata.getSqlFragment(java.lang.String)` back into a `Class` reference.
`Type` `OuterJoinLoadable.getSubclassPropertyType(int i)` Get the type of the numbered property of the class or a subclass.
`Type` `AbstractEntityPersister.getSubclassPropertyType(int i)`
`protected Type[]` `AbstractEntityPersister.getSubclassPropertyTypeClosure()`
`Type` `SQLLoadable.getType()` Get the type
`Type` `PropertyMapping.getType()` Get the type of the thing containing the properties
`Type` `BasicEntityPropertyMapping.getType()`
`Type` `AbstractEntityPersister.getType()`
`Type` `PropertyMapping.toType(String propertyName)` Given a component path expression, get the type of the property
`Type` `AbstractPropertyMapping.toType(String propertyName)`
`Type` `AbstractEntityPersister.toType(String propertyName)`

Methods in org.hibernate.persister.entity with parameters of type Type
`protected void` `AbstractPropertyMapping.addPropertyPath(String path, Type type, String[] columns, String[] columnReaders, String[] columnReaderTemplates, String[] formulaTemplates)`
`protected void` `AbstractPropertyMapping.initPropertyPaths(String path, Type type, String[] columns, String[] columnReaders, String[] columnReaderTemplates, String[] formulaTemplates, Mapping factory)`

Constructors in org.hibernate.persister.entity with parameters of type Type
`DiscriminatorType(Type underlyingType, Loadable persister)`

Uses of Type in org.hibernate.pretty

Methods in org.hibernate.pretty with parameters of type Type
`static String` `MessageHelper.infoString(EntityPersister persister, Object id, Type identifierType, SessionFactoryImplementor factory)` Generate an info message string relating to a particular entity,.
`String` `Printer.toString(Type[] types, Object[] values)`

Uses of Type in org.hibernate.property

Fields in org.hibernate.property declared as Type
`protected Type` `Dom4jAccessor.Dom4jGetter.propertyType`
`protected Type` `Dom4jAccessor.Dom4jSetter.propertyType`

Methods in org.hibernate.property with parameters of type Type
`static PropertyAccessor` `PropertyAccessorFactory.getDom4jPropertyAccessor(String nodeName, Type type, SessionFactoryImplementor factory)`

Constructors in org.hibernate.property with parameters of type Type
`Dom4jAccessor(String nodeName, Type propertyType, SessionFactoryImplementor factory)`

Uses of Type in org.hibernate.tuple

Methods in org.hibernate.tuple that return Type
`Type` `Property.getType()`

Constructors in org.hibernate.tuple with parameters of type Type
`IdentifierProperty(String name, String node, Type type, boolean embedded, IdentifierValue unsavedValue, IdentifierGenerator identifierGenerator)` Construct a non-virtual identifier property.
`IdentifierProperty(Type type, boolean embedded, boolean hasIdentifierMapper, IdentifierValue unsavedValue, IdentifierGenerator identifierGenerator)` Construct a virtual IdentifierProperty.
`Property(String name, String node, Type type)` Constructor for Property instances.
`StandardProperty(String name, String node, Type type, boolean lazy, boolean insertable, boolean updateable, boolean insertGenerated, boolean updateGenerated, boolean nullable, boolean checkable, boolean versionable, CascadeStyle cascadeStyle, FetchMode fetchMode)` Constructs StandardProperty instances.
`VersionProperty(String name, String node, Type type, boolean lazy, boolean insertable, boolean updateable, boolean insertGenerated, boolean updateGenerated, boolean nullable, boolean checkable, boolean versionable, CascadeStyle cascadeStyle, VersionValue unsavedValue)` Constructs VersionProperty instances.

Uses of Type in org.hibernate.tuple.entity

Methods in org.hibernate.tuple.entity that return Type
`Type` `AbstractEntityTuplizer.getIdentifierMapperType()`
`Type[]` `EntityMetamodel.getPropertyTypes()`

Uses of Type in org.hibernate.type

Subinterfaces of Type in org.hibernate.type
`interface` `AbstractComponentType` Deprecated. in favor of `CompositeType`
`interface` `AssociationType` A type that represents some kind of association between entities.
`interface` `BasicType` Marker interface for basic types.
`interface` `CompositeType` Contract for value types to hold collections and have cascades, etc.
`interface` `DiscriminatorType<T>` Additional contract for a `Type` may be used for a discriminator.
`interface` `IdentifierType<T>` Additional contract for a `Type` may be used for a discriminator.
`interface` `SingleColumnType<T>` Provide convenient methods for binding and extracting values for use with `BasicType`.
`interface` `VersionType<T>` Additional contract for types which may be used to version (and optimistic lock) data.

Classes in org.hibernate.type that implement Type
`class` `AbstractBynaryType` Deprecated. Use the `AbstractStandardBasicType` approach instead
`class` `AbstractCharArrayType` Deprecated. Use the `AbstractStandardBasicType` approach instead
`class` `AbstractLobType` Deprecated.
`class` `AbstractLongBinaryType` Deprecated. Use the `AbstractStandardBasicType` approach instead
`class` `AbstractLongStringType` Deprecated. Use the `AbstractStandardBasicType` approach instead
`class` `AbstractSingleColumnStandardBasicType<T>` TODO : javadoc
`class` `AbstractStandardBasicType<T>` TODO : javadoc
`class` `AbstractType` Abstract superclass of the built in Type hierarchy.
`class` `AdaptedImmutableType<T>` Optimize a mutable type, if the user promises not to mutable the instances.
`class` `AnyType` Handles "any" mappings
`class` `ArrayType` A type for persistent arrays.
`class` `BagType`
`class` `BigDecimalType` A type that maps between a `NUMERIC` and `BigDecimal`.
`class` `BigIntegerType` A type that maps between a `NUMERIC` and `BigInteger`.
`class` `BinaryType` A type that maps between a `VARBINARY` and `byte[]`
`class` `BlobType` A type that maps between `BLOB` and `Blob`
`class` `BooleanType` A type that maps between `BIT` and `Boolean`
`class` `ByteArrayBlobType` Deprecated. replaced by `WrappedMaterializedBlobType`
`class` `ByteType` A type that maps between `TINYINT` and `Byte`
`class` `CalendarDateType` A type mapping `DATE` and `Calendar`
`class` `CalendarType` A type that maps between `TIMESTAMP` and `Calendar`
`class` `CharacterArrayClobType` A type that maps between `CLOB` and `Character[]` Essentially a `MaterializedClobType` but represented as a Character[] in Java rather than String.
`class` `CharacterArrayType` A type that maps between `VARCHAR` and `Character[]`
`class` `CharacterType` A type that maps between `CHAR(1)` and `Character`
`class` `CharArrayType` A type that maps between `VARCHAR` and `char[]`
`class` `CharBooleanType` Deprecated. Use the `AbstractStandardBasicType` approach instead
`class` `ClassType` A type that maps between `VARCHAR` and `Class`
`class` `ClobType` A type that maps between `CLOB` and `Clob`
`class` `CollectionType` A type that handles Hibernate `PersistentCollection`s (including arrays).
`class` `ComponentType` Handles "component" mappings
`class` `CompositeCustomType` Adapts `CompositeUserType` to the `Type` interface
`class` `CurrencyType` A type that maps between `VARCHAR` and `Currency`
`class` `CustomCollectionType` A custom type for mapping user-written classes that implement `PersistentCollection`
`class` `CustomType` Adapts `UserType` to the generic `Type` interface, in order to isolate user code from changes in the internal Type contracts.
`class` `DateType` A type that maps between `DATE` and `Date`
`class` `DbTimestampType` `dbtimestamp`: An extension of `TimestampType` which maps to the database's current timestamp, rather than the jvm's current timestamp.
`class` `DoubleType` A type that maps between `DOUBLE` and `Double`
`class` `EmbeddedComponentType`
`class` `EntityType` Base for types which map associations to persistent entities.
`class` `FloatType` A type that maps between `FLOAT` and `Float`
`class` `IdentifierBagType`
`class` `ImageType` A type that maps between `LONGVARBINARY` and `byte[]`
`class` `ImmutableType` Deprecated. Use the `AbstractStandardBasicType` approach instead
`class` `IntegerType` A type that maps between `INTEGER` and @link Integer}
`class` `ListType`
`class` `LobType<T>` A base type used to define a LOB type; it also provides alternatives that can override this type via `LobType.getAlternatives()` getAlternatives()}
`class` `LocaleType` A type that maps between `VARCHAR` and @link Locale}
`class` `LongType` A type that maps between `BIGINT` and `Long`
`class` `ManyToOneType` A many-to-one association to an entity.
`class` `MapType`
`class` `MaterializedBlobType` A type that maps between `BLOB` and `byte[]`
`class` `MaterializedClobType` A type that maps between `CLOB` and `String`
`class` `MetaType`
`class` `MutableType` Deprecated. Use the `AbstractStandardBasicType` approach instead
`class` `NullableType` Deprecated. Use the `AbstractStandardBasicType` approach instead
`class` `NumericBooleanType` A type that maps between `INTEGER` and `Boolean` (using 1 and 0)
`class` `ObjectType` Specific adaptation of the "any" type to the old deprecated "object" type
`class` `OneToOneType` A one-to-one association to an entity
`class` `OrderedMapType` A specialization of the map type, with (resultset-based) ordering.
`class` `OrderedSetType` A specialization of the set type, with (resultset-based) ordering.
`class` `PostgresUUIDType` Specialized type mapping for `UUID` and the Postgres UUID data type (which is mapped as OTHER in its JDBC driver).
`class` `PrimitiveByteArrayBlobType` Deprecated. replaced by `MaterializedBlobType`
`class` `PrimitiveCharacterArrayClobType` Map a char[] to a Clob
`class` `SerializableToBlobType`
`class` `SerializableType<T extends Serializable>` A type that maps between a `VARBINARY` and `Serializable` classes.
`class` `SetType`
`class` `ShortType` A type that maps between `SMALLINT` and `Short`
`class` `SortedMapType`
`class` `SortedSetType`
`class` `SpecialOneToOneType` A one-to-one association that maps to specific formula(s) instead of the primary key column of the owning entity.
`class` `StringType` A type that maps between `VARCHAR` and `String`
`class` `TextType` A type that maps between `LONGVARCHAR` and `String`
`class` `TimestampType` A type that maps between `TIMESTAMP` and `Timestamp`
`class` `TimeType` A type that maps between `TIME` and `Time`
`class` `TimeZoneType` A type mapping `VARCHAR` and `TimeZone`
`class` `TrueFalseType` A type that maps between `CHAR(1)` and `Boolean` (using 'T' and 'F')
`class` `UrlType` A type that maps between `VARCHAR` and `URL`
`class` `UUIDBinaryType` A type mapping `Types.BINARY` and `UUID`
`class` `UUIDCharType` A type mapping `Types.CHAR` (or `Types.VARCHAR`) and `UUID`
`class` `WrappedMaterializedBlobType` A type that maps JDBC `BLOB` and `Byte[]`.
`class` `WrapperBinaryType` A type mapping `VARBINARY` and `Byte[]`
`class` `YesNoType` A type that maps between `CHAR(1)` and `Boolean` (using 'Y' and 'N')

Methods in org.hibernate.type that return Type
`Type` `TypeFactory.any(Type metaType, Type identifierType)`
`Type` `TypeFactory.byClass(Class clazz, Properties parameters)`
`Type` `CollectionType.getElementType(SessionFactoryImplementor factory)` Get the Hibernate type of the collection elements
`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.
`Type` `Type.getSemiResolvedType(SessionFactoryImplementor factory)` Get the type of a semi-resolved value.
`Type` `EntityType.getSemiResolvedType(SessionFactoryImplementor factory)`
`Type` `AbstractType.getSemiResolvedType(SessionFactoryImplementor factory)`
`Type` `AbstractStandardBasicType.getSemiResolvedType(SessionFactoryImplementor factory)`
`Type[]` `CompositeType.getSubtypes()` Get the types of the component properties
`Type[]` `CompositeCustomType.getSubtypes()`
`Type[]` `ComponentType.getSubtypes()`
`Type[]` `AnyType.getSubtypes()`
`Type` `TypeResolver.heuristicType(String typeName)` See `TypeResolver.heuristicType(String, Properties)`
`Type` `TypeResolver.heuristicType(String typeName, Properties parameters)` Uses heuristics to deduce the proper `Type` given a string naming the type or Java class.
`Type` `TypeFactory.type(Class<Type> typeClass, Properties parameters)`

Methods in org.hibernate.type with parameters of type Type
`Type` `TypeFactory.any(Type metaType, Type identifierType)`
`static Object[]` `TypeHelper.assemble(Serializable[] row, Type[] types, SessionImplementor session, Object owner)` Apply the `assemble(java.io.Serializable, org.hibernate.engine.SessionImplementor, java.lang.Object)` operation across a series of values.
`static void` `TypeHelper.beforeAssemble(Serializable[] row, Type[] types, SessionImplementor session)` Apply the `beforeAssemble(java.io.Serializable, org.hibernate.engine.SessionImplementor)` operation across a series of values.
`static void` `TypeHelper.deepCopy(Object[] values, Type[] types, boolean[] copy, Object[] target, SessionImplementor session)` Deep copy a series of values from one array to another...
`static Serializable[]` `TypeHelper.disassemble(Object[] row, Type[] types, boolean[] nonCacheable, SessionImplementor session, Object owner)` Apply the `disassemble(java.lang.Object, org.hibernate.engine.SessionImplementor, java.lang.Object)` operation across a series of values.
`static Object[]` `TypeHelper.replace(Object[] original, Object[] target, Type[] types, SessionImplementor session, Object owner, Map copyCache)` Apply the `replace(java.lang.Object, java.lang.Object, org.hibernate.engine.SessionImplementor, java.lang.Object, java.util.Map)` operation across a series of values.
`static Object[]` `TypeHelper.replace(Object[] original, Object[] target, Type[] types, SessionImplementor session, Object owner, Map copyCache, ForeignKeyDirection foreignKeyDirection)` Apply the `replace(java.lang.Object, java.lang.Object, org.hibernate.engine.SessionImplementor, java.lang.Object, java.util.Map)` operation across a series of values.

`static Object[]`

`TypeHelper.replaceAssociations(Object[] original, Object[] target, Type[] types, SessionImplementor session, Object owner, Map copyCache, ForeignKeyDirection foreignKeyDirection)`
Apply the `replace(java.lang.Object, java.lang.Object, org.hibernate.engine.SessionImplementor, java.lang.Object, java.util.Map)` operation across a series of values, as long as the corresponding `Type` is an association.

Method parameters in org.hibernate.type with type arguments of type Type
`Type` `TypeFactory.type(Class<Type> typeClass, Properties parameters)`

Constructors in org.hibernate.type with parameters of type Type
`AnyType(Type metaType, Type identifierType)`
`MetaType(Map values, Type baseType)`

Uses of Type in org.hibernate.usertype

Methods in org.hibernate.usertype that return Type
`Type[]` `CompositeUserType.getPropertyTypes()` Get the corresponding "property types".

Uses of Type in org.hibernate.util

Fields in org.hibernate.util declared as Type
`static Type[]` `ArrayHelper.EMPTY_TYPE_ARRAY`

Methods in org.hibernate.util that return Type
`static Type[]` `ArrayHelper.toTypeArray(Collection coll)`

Methods in org.hibernate.util with parameters of type Type
`static Constructor` `ReflectHelper.getConstructor(Class clazz, Type[] types)` Retrieve a constructor for the given class, with arguments matching the specified Hibernate mapping `types`.

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