Java Code Examples for org.hibernate.type.Type

@Override
@SuppressWarnings({"deprecation", "unchecked"})
public Iterator getDeletes(CollectionPersister persister, boolean indexIsFormula) throws HibernateException {
	final Type indexType = persister.getIndexType();
	final HashMap snapshot = (HashMap) getSnapshot();
	final HashMap deletes = (HashMap) snapshot.clone();
	deletes.keySet().removeAll( ( (HashMap) getSnapshot( persister ) ).keySet() );
	final ArrayList deleteList = new ArrayList( deletes.size() );
	for ( Object o : deletes.entrySet() ) {
		final Map.Entry me = (Map.Entry) o;
		final Object object = indexIsFormula
				? me.getValue()
				: ( (XmlRepresentableType) indexType ).fromXMLString( (String) me.getKey(), persister.getFactory() );
		if ( object != null ) {
			deleteList.add( object );
		}
	}
	return deleteList.iterator();
}
 

/**
 * Cascade an action to a to-one association or any type
 */
private void cascadeToOne(
		final Object parent,
		final Object child,
		final Type type,
		final CascadeStyle style,
		final Object anything,
		final boolean isCascadeDeleteEnabled) {
	final String entityName = type.isEntityType()
			? ( (EntityType) type ).getAssociatedEntityName()
			: null;
	if ( style.reallyDoCascade( action ) ) {
		//not really necessary, but good for consistency...
		eventSource.getPersistenceContext().addChildParent( child, parent );
		try {
			action.cascade( eventSource, child, entityName, anything, isCascadeDeleteEnabled );
		}
		finally {
			eventSource.getPersistenceContext().removeChildParent( child );
		}
	}
}
 

@Override
protected Object[] getResultRow(Object[] row, ResultSet rs, SessionImplementor session)
		throws SQLException, HibernateException {
	final Object[] result;
	if ( translator.hasProjection() ) {
		Type[] types = translator.getProjectedTypes();
		result = new Object[types.length];
		String[] columnAliases = translator.getProjectedColumnAliases();
		for ( int i=0, pos=0; i<result.length; i++ ) {
			int numColumns = types[i].getColumnSpan( session.getFactory() );
			if ( numColumns > 1 ) {
		    	String[] typeColumnAliases = ArrayHelper.slice( columnAliases, pos, numColumns );
				result[i] = types[i].nullSafeGet(rs, typeColumnAliases, session, null);
			}
			else {
				result[i] = types[i].nullSafeGet(rs, columnAliases[pos], session, null);
			}
			pos += numColumns;
		}
	}
	else {
		result = toResultRow( row );
	}
	return result;
}
 

private void initCollectionPropertyMap(String aliasName, Type type, String[] columnAliases, String[] columnNames) {

		collectionPropertyColumnAliases.put( aliasName, columnAliases );
		collectionPropertyColumnNames.put( aliasName, columnNames );

		if ( type.isComponentType() ) {
			CompositeType ct = (CompositeType) type;
			String[] propertyNames = ct.getPropertyNames();
			for ( int i = 0; i < propertyNames.length; i++ ) {
				String name = propertyNames[i];
				collectionPropertyColumnAliases.put( aliasName + "." + name, columnAliases[i] );
				collectionPropertyColumnNames.put( aliasName + "." + name, columnNames[i] );
			}
		}

	}
 

@Override
@SuppressWarnings("deprecation")
public Serializable disassemble(CollectionPersister persister) throws HibernateException {
	final Type elementType = persister.getElementType();
	final String indexNodeName = getIndexAttributeName( persister );
	final List elements =  element.elements( persister.getElementNodeName() );
	final int length = elements.size();
	final Serializable[] result = new Serializable[length];
	for ( int i=0; i<length; i++ ) {
		final Element elem = (Element) elements.get( i );
		final Object object = elementType.fromXMLNode( elem, persister.getFactory() );
		final Integer index = IntegerType.INSTANCE.fromString( getIndex( elem, indexNodeName, i ) );
		result[index] = elementType.disassemble( object, getSession(), null );
	}
	return result;
}
 

@Override
@SuppressWarnings("deprecation")
public boolean equalsSnapshot(CollectionPersister persister) throws HibernateException {
	final Type elementType = persister.getElementType();
	final ArrayList snapshot = (ArrayList) getSnapshot();
	final List elements = element.elements( persister.getElementNodeName() );
	if ( snapshot.size() != elements.size() ) {
		return false;
	}
	for ( int i=0; i<snapshot.size(); i++ ) {
		final Object old = snapshot.get( i );
		final Element elem = (Element) elements.get( i );
		final Object current = elementType.fromXMLNode( elem, persister.getFactory() );
		if ( elementType.isDirty( old, current, getSession() ) ) {
			return false;
		}
	}
	return true;
}
 

/**
 * Find all non-nullable references to entities that have not yet
 * been inserted in the database, where the foreign key
 * is a reference to an unsaved transient entity. .
 *
 * @param entityName - the entity name
 * @param entity - the entity instance
 * @param values - insertable properties of the object (including backrefs),
 * possibly with substitutions
 * @param isEarlyInsert - true if the entity needs to be executed as soon as possible
 * (e.g., to generate an ID)
 * @param session - the session
 *
 * @return the transient unsaved entity dependencies that are non-nullable,
 *         or null if there are none.
 */
public static NonNullableTransientDependencies findNonNullableTransientEntities(
		String entityName,
		Object entity,
		Object[] values,
		boolean isEarlyInsert,
		SessionImplementor session) {
	final Nullifier nullifier = new Nullifier( entity, false, isEarlyInsert, session );
	final EntityPersister persister = session.getEntityPersister( entityName, entity );
	final String[] propertyNames = persister.getPropertyNames();
	final Type[] types = persister.getPropertyTypes();
	final boolean[] nullability = persister.getPropertyNullability();
	final NonNullableTransientDependencies nonNullableTransientEntities = new NonNullableTransientDependencies();
	for ( int i = 0; i < types.length; i++ ) {
		collectNonNullableTransientEntities(
				nullifier,
				values[i],
				propertyNames[i],
				types[i],
				nullability[i],
				session,
				nonNullableTransientEntities
		);
	}
	return nonNullableTransientEntities.isEmpty() ? null : nonNullableTransientEntities;
}
 

@Override
@SuppressWarnings("deprecation")
public Object readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)
		throws HibernateException, SQLException {
	final Object object = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() );
	final Type elementType = persister.getElementType();
	final Element subElement = element.addElement( persister.getElementNodeName() );
	elementType.setToXMLNode( subElement, object, persister.getFactory() );
	return object;
}
 

private Type resolveDateTimeArithmeticResultType(Type lhType, Type rhType) {
	// here, we work under the following assumptions:
	//      ------------ valid cases --------------------------------------
	//      1) datetime + {something other than datetime} : always results
	//              in a datetime ( db will catch invalid conversions )
	//      2) datetime - datetime : always results in a DOUBLE
	//      3) datetime - {something other than datetime} : always results
	//              in a datetime ( db will catch invalid conversions )
	//      ------------ invalid cases ------------------------------------
	//      4) datetime + datetime
	//      5) {something other than datetime} - datetime
	//      6) datetime * {any type}
	//      7) datetime / {any type}
	//      8) {any type} / datetime
	// doing so allows us to properly handle parameters as either the left
	// or right side here in the majority of cases
	boolean lhsIsDateTime = isDateTimeType( lhType );
	boolean rhsIsDateTime = isDateTimeType( rhType );

	// handle the (assumed) valid cases:
	// #1 - the only valid datetime addition synatx is one or the other is a datetime (but not both)
	if ( getType() == HqlSqlTokenTypes.PLUS ) {
		// one or the other needs to be a datetime for us to get into this method in the first place...
		return lhsIsDateTime ? lhType : rhType;
	}
	else if ( getType() == HqlSqlTokenTypes.MINUS ) {
		// #3 - note that this is also true of "datetime - :param"...
		if ( lhsIsDateTime && !rhsIsDateTime ) {
			return lhType;
		}
		// #2
		if ( lhsIsDateTime && rhsIsDateTime ) {
			return StandardBasicTypes.DOUBLE;
		}
	}
	return null;
}
 

@Override
public Query setParameterList(String name, Collection vals, Type type) throws HibernateException {
	if ( !parameterMetadata.getNamedParameterNames().contains( name ) ) {
		throw new IllegalArgumentException("Parameter " + name + " does not exist as a named parameter in [" + getQueryString() + "]");
	}
	namedParameterLists.put( name, new TypedValue( type, vals ) );
	return this;
}
 

@Override
public Type getDataType() {
	if ( super.getDataType() == null ) {
		FromElement fromElement = getLhs().getFromElement();
		if ( fromElement == null ) {
			return null;
		}
		// If the lhs is a collection, use CollectionPropertyMapping
		Type propertyType = fromElement.getPropertyType( propertyName, propertyPath );
		LOG.debugf( "getDataType() : %s -> %s", propertyPath, propertyType );
		super.setDataType( propertyType );
	}
	return super.getDataType();
}
 

/**
 * Dispatch each property value to processValue().
 *
 * @param values
 * @param types
 * @throws HibernateException
 */
void processValues(Object[] values, Type[] types) throws HibernateException {
	for ( int i=0; i<types.length; i++ ) {
		if ( includeProperty(values, i) ) {
			processValue( i, values, types );
		}
	}
}
 

private DiscriminatorMetadata buildTypeDiscriminatorMetadata() {
	return new DiscriminatorMetadata() {
		public String getSqlFragment(String sqlQualificationAlias) {
			return toColumns( sqlQualificationAlias, ENTITY_CLASS )[0];
		}

		public Type getResolutionType() {
			return new DiscriminatorType( getDiscriminatorType(), AbstractEntityPersister.this );
		}
	};
}
 

private Object[] createDeletedState(EntityPersister persister, Object[] currentState, EventSource session) {
		Type[] propTypes = persister.getPropertyTypes();
		final Object[] deletedState = new Object[propTypes.length];
//		TypeFactory.deepCopy( currentState, propTypes, persister.getPropertyUpdateability(), deletedState, session );
		boolean[] copyability = new boolean[propTypes.length];
		java.util.Arrays.fill( copyability, true );
		TypeHelper.deepCopy( currentState, propTypes, copyability, deletedState, session );
		return deletedState;
	}
 

public String toString(Type[] types, Object[] values) throws HibernateException {
	StringBuilder buffer = new StringBuilder();
	for ( int i=0; i<types.length; i++ ) {
		if ( types[i]!=null ) {
			buffer.append( types[i].toLoggableString( values[i], factory ) ).append( ", " );
		}
	}
	return buffer.toString();
}
 

public Type getType() throws MappingException {
	final Type metaType = getMappings().getTypeResolver().heuristicType( metaTypeName );

	return getMappings().getTypeResolver().getTypeFactory().any(
			metaValues == null ? metaType : new MetaType( metaValues, metaType ),
			getMappings().getTypeResolver().heuristicType( identifierTypeName )
	);
}
 

@Override
public int[] findDirty(
		Object entity,
		Serializable id,
		Object[] currentState,
		Object[] previousState,
		String[] propertyNames,
		Type[] types) {
	return null;
}
 

private void processFilterDefinitions() {
	if ( mappingRoot().getFilterDef() == null ) {
		return;
	}

	for ( JaxbHibernateMapping.JaxbFilterDef filterDefinition : mappingRoot().getFilterDef() ) {
		final String name = filterDefinition.getName();
		final Map<String,Type> parameters = new HashMap<String, Type>();
		String condition = null;
		for ( Object o : filterDefinition.getContent() ) {
			if ( o instanceof String ) {
				// represents the condition
				if ( condition != null ) {
					// log?
				}
				condition = (String) o;
			}
			else if ( o instanceof JaxbHibernateMapping.JaxbFilterDef.JaxbFilterParam ) {
				final JaxbHibernateMapping.JaxbFilterDef.JaxbFilterParam paramElement =
						JaxbHibernateMapping.JaxbFilterDef.JaxbFilterParam.class.cast( o );
				// todo : should really delay this resolution until later to allow typedef names
				parameters.put(
						paramElement.getName(),
						metadata.getTypeResolver().heuristicType( paramElement.getType() )
				);
			}
			else {
				throw new MappingException( "Unrecognized nested filter content", origin() );
			}
		}
		if ( condition == null ) {
			condition = filterDefinition.getCondition();
		}
		metadata.addFilterDefinition( new FilterDefinition( name, condition, parameters ) );
	}
}
 

private void resolveDiscriminatorTypeInformation(EntityDiscriminator discriminator) {
	// perform any needed type resolutions for discriminator
	Type resolvedHibernateType = determineSingularTypeFromDescriptor( discriminator.getExplicitHibernateTypeDescriptor() );
	if ( resolvedHibernateType != null ) {
		pushHibernateTypeInformationDownIfNeeded(
				discriminator.getExplicitHibernateTypeDescriptor(),
				discriminator.getBoundValue(),
				resolvedHibernateType
		);
	}
}
 

public Type getDataType() {
	final AST expression = getFirstChild();
	// option is used to hold each WHEN/ELSE in turn
	AST option = expression.getNextSibling();
	while ( option != null ) {
		final AST result;
		if ( option.getType() == HqlSqlTokenTypes.WHEN ) {
			result = option.getFirstChild().getNextSibling();
		}
		else if ( option.getType() == HqlSqlTokenTypes.ELSE ) {
			result = option.getFirstChild();
		}
		else {
			throw new QueryException(
					"Unexpected node type :" +
							ASTUtil.getTokenTypeName( HqlSqlTokenTypes.class, option.getType() ) +
							"; expecting WHEN or ELSE"
			);
		}

		if ( SqlNode.class.isInstance( result ) ) {
			final Type nodeDataType = ( (SqlNode) result ).getDataType();
			if ( nodeDataType != null ) {
				return nodeDataType;
			}
		}

		option = option.getNextSibling();
	}

	throw new QueryException( "Could not determine data type for simple case statement" );
}
 

private Type getHeuristicType(String typeName, Properties typeParameters) {
	if ( typeName != null ) {
		try {
			return metadata.getTypeResolver().heuristicType( typeName, typeParameters );
		}
		catch (Exception ignore) {
		}
	}

	return null;
}
 

public EntityUniqueKey(
		final String entityName,
		final String uniqueKeyName,
		final Object semiResolvedKey,
		final Type keyType,
		final EntityMode entityMode,
		final SessionFactoryImplementor factory) {
	this.uniqueKeyName = uniqueKeyName;
	this.entityName = entityName;
	this.key = semiResolvedKey;
	this.keyType = keyType.getSemiResolvedType( factory );
	this.entityMode = entityMode;
	this.hashCode = generateHashCode( factory );
}
 

public QueryParameters(
		final Type[] positionalParameterTypes,
		final Object[] positionalParameterValues,
		final LockOptions lockOptions,
		final RowSelection rowSelection,
		final boolean isReadOnlyInitialized,
		final boolean readOnly,
		final boolean cacheable,
		final String cacheRegion,
		//final boolean forceCacheRefresh,
		final String comment,
		final List<String> queryHints,
		final boolean isLookupByNaturalKey,
		final ResultTransformer transformer) {
	this(
			positionalParameterTypes,
			positionalParameterValues,
			null,
			lockOptions,
			rowSelection,
			isReadOnlyInitialized,
			readOnly,
			cacheable,
			cacheRegion,
			comment,
			queryHints,
			null,
			transformer
	);
	isNaturalKeyLookup = isLookupByNaturalKey;
}
 

private void collectionProperty(AST path, AST name) throws SemanticException {
	if ( path == null ) {
		throw new SemanticException( "Collection function " + name.getText() + " has no path!" );
	}

	SqlNode expr = (SqlNode) path;
	Type type = expr.getDataType();
	LOG.debugf( "collectionProperty() :  name=%s type=%s", name, type );

	resolveCollectionProperty( expr );
}
 

@Override
public boolean onLoad(Object entity, Serializable id, Object[] state, String[] propertyNames,
		Type[] types) throws CallbackException {
	boolean changed = false;
	for (PersistListener listener: listeners) {
		if (listener.onLoad(entity, id, state, propertyNames, types))
			changed = true;
	}
		
	return changed;
}
 

protected Type determineType(int paramPosition, Object paramValue, Type defaultType) {
	Type type = parameterMetadata.getOrdinalParameterExpectedType( paramPosition + 1 );
	if ( type == null ) {
		type = defaultType;
	}
	return type;
}
 

NamedParameterRegistration(
		ProcedureCallImpl procedureCall,
		String name,
		ParameterMode mode,
		Class<T> type,
		Type hibernateType) {
	super( procedureCall, name, mode, type, hibernateType );
}
 

@Override
public void setHibernateType(Type type) {
	if ( type == null ) {
		throw new IllegalArgumentException( "Type cannot be null" );
	}
	this.hibernateType = type;
	this.sqlTypes = hibernateType.sqlTypes( session().getFactory() );
}
 

public static String[][] generateColumnNames(Type[] types, SessionFactoryImplementor f) throws MappingException {
	String[][] columnNames = new String[types.length][];
	for ( int i = 0; i < types.length; i++ ) {
		int span = types[i].getColumnSpan( f );
		columnNames[i] = new String[span];
		for ( int j = 0; j < span; j++ ) {
			columnNames[i][j] = NameGenerator.scalarName( i, j );
		}
	}
	return columnNames;
}
 

public Type findFunctionReturnType(String functionName, SQLFunction sqlFunction, AST firstArgument) {
	// determine the type of the first argument...
	Type argumentType = null;
	if ( firstArgument != null ) {
		if ( "cast".equals( functionName ) ) {
			argumentType = sfi.getTypeResolver().heuristicType( firstArgument.getNextSibling().getText() );
		}
		else if ( SqlNode.class.isInstance( firstArgument ) ) {
			argumentType = ( (SqlNode) firstArgument ).getDataType();
		}
	}

	return sqlFunction.getReturnType( argumentType, sfi );
}
 

private int countOccurrences(Object element, List list, Type elementType)
		throws HibernateException {
	final Iterator iter = list.iterator();
	int result = 0;
	while ( iter.hasNext() ) {
		if ( elementType.isSame( element, iter.next() ) ) {
			result++;
		}
	}
	return result;
}
 

protected AbstractEntityBasedAttribute(
		EntityPersister source,
		SessionFactoryImplementor sessionFactory,
		int attributeNumber,
		String attributeName,
		Type attributeType,
		BaselineAttributeInformation attributeInformation) {
	super( source, sessionFactory, attributeNumber, attributeName, attributeType, attributeInformation );
}
 

@Override
@SuppressWarnings({"deprecation", "unchecked"})
public Iterator entries(CollectionPersister persister) {
	final Type elementType = persister.getElementType();
	final List subElements =  element.elements( persister.getElementNodeName() );
	final int length = subElements.size();
	final List result = new ArrayList(length);
	for ( Object subElementO : subElements ) {
		final Element subElement = (Element) subElementO;
		final Object object = elementType.fromXMLNode( subElement, persister.getFactory() );
		result.add( object );
	}
	return result.iterator();
}
 

/**
 * Renders an entity to a string.
 *
 * @param entityName the entity name
 * @param entity an actual entity object, not a proxy!
 * @return the entity rendered to a string
 */
public String toString(String entityName, Object entity) throws HibernateException {
	EntityPersister entityPersister = factory.getEntityPersister( entityName );

	if ( entityPersister == null ) {
		return entity.getClass().getName();
	}

	Map<String,String> result = new HashMap<String,String>();

	if ( entityPersister.hasIdentifierProperty() ) {
		result.put(
			entityPersister.getIdentifierPropertyName(),
			entityPersister.getIdentifierType().toLoggableString( entityPersister.getIdentifier( entity ), factory )
		);
	}

	Type[] types = entityPersister.getPropertyTypes();
	String[] names = entityPersister.getPropertyNames();
	Object[] values = entityPersister.getPropertyValues( entity );
	for ( int i=0; i<types.length; i++ ) {
		if ( !names[i].startsWith("_") ) {
			String strValue = values[i]==LazyPropertyInitializer.UNFETCHED_PROPERTY ?
				values[i].toString() :
				types[i].toLoggableString( values[i], factory );
			result.put( names[i], strValue );
		}
	}
	return entityName + result.toString();
}
 

private boolean indicatesCollection(Type type) {
	if ( type.isCollectionType() ) {
		return true;
	}
	else if ( type.isComponentType() ) {
		Type[] subtypes = ( (CompositeType) type ).getSubtypes();
		for ( int i = 0; i < subtypes.length; i++ ) {
			if ( indicatesCollection( subtypes[i] ) ) {
				return true;
			}
		}
	}
	return false;
}
 

protected AbstractParameterRegistrationImpl(
		ProcedureCallImpl procedureCall,
		String name,
		ParameterMode mode,
		Class<T> type,
		Type hibernateType) {
	this( procedureCall, null, name, mode, type, hibernateType );
}
 

/**
 * Check that the requested type is compatible with the result type, and
 * return the column value.  This version makes sure the the classes
 * are "assignable".
 *
 * @param col the column
 * @param returnType any type
 */
protected final Object getNonFinal(int col, Type returnType) throws HibernateException {
	if ( holderInstantiator!=null ) {
		throw new HibernateException("query specifies a holder class");
	}

	if ( returnType.getReturnedClass().isAssignableFrom( types[col].getReturnedClass() ) ) {
		return get(col);
	}
	else {
		return throwInvalidColumnTypeException(col, types[col], returnType);
	}
}
 

@Override
public String toSqlString(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
	final String[] columns = criteriaQuery.findColumns( propertyName, criteria );
	final Type type = criteriaQuery.getTypeUsingProjection( criteria, propertyName );
	final StringBuilder fragment = new StringBuilder();

	if ( columns.length > 1 ) {
		fragment.append( '(' );
	}
	final SessionFactoryImplementor factory = criteriaQuery.getFactory();
	final int[] sqlTypes = type.sqlTypes( factory );
	for ( int i = 0; i < columns.length; i++ ) {
		final boolean lower = ignoreCase && (sqlTypes[i] == Types.VARCHAR || sqlTypes[i] == Types.CHAR);
		if ( lower ) {
			fragment.append( factory.getDialect().getLowercaseFunction() ).append( '(' );
		}
		fragment.append( columns[i] );
		if ( lower ) {
			fragment.append( ')' );
		}

		fragment.append( getOp() ).append( "?" );
		if ( i < columns.length - 1 ) {
			fragment.append( " and " );
		}
	}
	if ( columns.length > 1 ) {
		fragment.append( ')' );
	}
	return fragment.toString();
}
 

@Override
public void startingCollectionElements(CollectionElementDefinition elementDefinition) {
	final Type elementType = elementDefinition.getType();
	log.tracef(
			"%s Starting collection element graph : %s",
			StringHelper.repeat( ">>", fetchSourceStack.size() ),
			elementDefinition.getCollectionDefinition().getCollectionPersister().getRole()
	);

	final CollectionReference collectionReference = currentCollection();
	final CollectionFetchableElement elementGraph = collectionReference.getElementGraph();

	if ( elementType.isAssociationType() || elementType.isComponentType() ) {
		if ( elementGraph == null ) {
			throw new IllegalStateException(
					"CollectionReference did not return an expected element graph : " +
							elementDefinition.getCollectionDefinition().getCollectionPersister().getRole()
			);
		}
		if ( !elementType.isAnyType() ) {
			pushToStack( (ExpandingFetchSource) elementGraph );
		}
	}
	else {
		if ( elementGraph != null ) {
			throw new IllegalStateException(
					"CollectionReference returned an unexpected element graph : " +
							elementDefinition.getCollectionDefinition().getCollectionPersister().getRole()
			);
		}
	}
}
 

@Override
public Type getTypeUsingProjection(Criteria subcriteria, String propertyName)
		throws HibernateException {

	//first look for a reference to a projection alias
	final Projection projection = rootCriteria.getProjection();
	Type[] projectionTypes = projection == null ?
	                         null :
	                         projection.getTypes( propertyName, subcriteria, this );

	if ( projectionTypes == null ) {
		try {
			//it does not refer to an alias of a projection,
			//look for a property
			return getType( subcriteria, propertyName );
		}
		catch ( HibernateException he ) {
			//not found in inner query , try the outer query
			if ( outerQueryTranslator != null ) {
				return outerQueryTranslator.getType( subcriteria, propertyName );
			}
			else {
				throw he;
			}
		}
	}
	else {
		if ( projectionTypes.length != 1 ) {
			//should never happen, i think
			throw new QueryException( "not a single-length projection: " + propertyName );
		}
		return projectionTypes[0];
	}
}