org.hibernate.query.criteria.internal.path.SingularAttributePath Maven / Gradle / Ivy
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or .
*/
package org.hibernate.query.criteria.internal.path;
import java.io.Serializable;
import javax.persistence.metamodel.Attribute;
import javax.persistence.metamodel.Bindable;
import javax.persistence.metamodel.EmbeddableType;
import javax.persistence.metamodel.IdentifiableType;
import javax.persistence.metamodel.ManagedType;
import javax.persistence.metamodel.SingularAttribute;
import org.hibernate.query.criteria.internal.CriteriaBuilderImpl;
import org.hibernate.query.criteria.internal.PathSource;
import org.hibernate.query.criteria.internal.compile.RenderingContext;
/**
* Models a path for a {@link SingularAttribute} generally obtained from a
* {@link javax.persistence.criteria.Path#get(SingularAttribute)} call
*
* @author Steve Ebersole
*/
public class SingularAttributePath extends AbstractPathImpl implements Serializable {
private final SingularAttribute attribute;
private final ManagedType managedType;
@SuppressWarnings({ "unchecked" })
public SingularAttributePath(
CriteriaBuilderImpl criteriaBuilder,
Class javaType,
PathSource pathSource,
SingularAttribute attribute) {
super( criteriaBuilder, javaType, pathSource );
this.attribute = attribute;
this.managedType = resolveManagedType( attribute );
}
private ManagedType resolveManagedType(SingularAttribute attribute) {
if ( Attribute.PersistentAttributeType.BASIC == attribute.getPersistentAttributeType() ) {
return null;
}
else if ( Attribute.PersistentAttributeType.EMBEDDED == attribute.getPersistentAttributeType() ) {
return (EmbeddableType) attribute.getType();
}
else {
return (IdentifiableType) attribute.getType();
}
}
@Override
public SingularAttribute getAttribute() {
return attribute;
}
@Override
public Bindable getModel() {
return getAttribute();
}
@Override
protected boolean canBeDereferenced() {
return managedType != null;
}
@Override
protected Attribute locateAttributeInternal(String attributeName) {
final Attribute attribute = managedType.getAttribute( attributeName );
// ManagedType.locateAttribute should throw exception rather than return
// null, but just to be safe...
if ( attribute == null ) {
throw new IllegalArgumentException( "Could not resolve attribute named " + attributeName );
}
return attribute;
}
@Override
public SingularAttributePath treatAs(Class treatAsType) {
return new TreatedSingularAttributePath( this, treatAsType );
}
public static class TreatedSingularAttributePath extends SingularAttributePath {
private final SingularAttributePath original;
private final Class treatAsType;
@SuppressWarnings("unchecked")
public TreatedSingularAttributePath(SingularAttributePath original, Class treatAsType) {
super(
original.criteriaBuilder(),
treatAsType,
original.getPathSource(),
(SingularAttribute) original.getAttribute()
);
this.original = original;
this.treatAsType = treatAsType;
}
@Override
public String getAlias() {
return original.getAlias();
}
@Override
public void prepareAlias(RenderingContext renderingContext) {
// do nothing...
}
@Override
public String render(RenderingContext renderingContext) {
return "treat(" + original.render( renderingContext ) + " as " + treatAsType.getName() + ")";
}
}
}