| Methods Summary |
|---|
| private void | addDestination(org.hibernate.hql.ast.tree.FromElement fromElement)
destinations.add( fromElement );
|
| protected void | appendDisplayText(java.lang.StringBuffer buf)
buf.append( isImplied() ? (
isImpliedInFromClause() ? "implied in FROM clause" : "implied" )
: "explicit" );
buf.append( "," ).append( isCollectionJoin() ? "collection join" : "not a collection join" );
buf.append( "," ).append( fetch ? "fetch join" : "not a fetch join" );
buf.append( "," ).append( isAllPropertyFetch ? "fetch all properties" : "fetch non-lazy properties" );
buf.append( ",classAlias=" ).append( getClassAlias() );
buf.append( ",role=" ).append( role );
buf.append( ",tableName=" ).append( getTableName() );
buf.append( ",tableAlias=" ).append( getTableAlias() );
FromElement origin = getRealOrigin();
buf.append( ",origin=" ).append( origin == null ? "null" : origin.getText() );
buf.append( ",colums={" );
if ( columns != null ) {
for ( int i = 0; i < columns.length; i++ ) {
buf.append( columns[i] );
if ( i < columns.length ) {
buf.append( " " );
}
}
}
buf.append( ",className=" ).append( className );
buf.append( "}" );
|
| void | checkInitialized()
if ( !initialized ) {
throw new IllegalStateException( "FromElement has not been initialized!" );
}
|
| private void | doInitialize(FromClause fromClause, java.lang.String tableAlias, java.lang.String className, java.lang.String classAlias, org.hibernate.persister.entity.EntityPersister persister, org.hibernate.type.EntityType type)
if ( initialized ) {
throw new IllegalStateException( "Already initialized!!" );
}
this.fromClause = fromClause;
this.tableAlias = tableAlias;
this.className = className;
this.classAlias = classAlias;
this.elementType = new FromElementType( this, persister, type );
// Register the FromElement with the FROM clause, now that we have the names and aliases.
fromClause.registerFromElement( this );
if ( log.isDebugEnabled() ) {
log.debug( fromClause + " : " + className + " ("
+ ( classAlias == null ? "no alias" : classAlias ) + ") -> " + tableAlias );
}
|
| public boolean | equals(java.lang.Object obj)
return super.equals( obj );
|
| public java.lang.String | getClassAlias()
return classAlias;
//return classAlias == null ? className : classAlias;
|
| public java.lang.String | getClassName()
return className;
|
| public java.lang.String | getCollectionSuffix()
return elementType.getCollectionSuffix();
|
| public java.lang.String | getCollectionTableAlias()
return collectionTableAlias;
|
| public org.hibernate.type.Type | getDataType()
return elementType.getDataType();
|
| public java.util.List | getDestinations()
return destinations;
|
| public java.lang.String | getDisplayText()Returns additional display text for the AST node.
StringBuffer buf = new StringBuffer();
buf.append( "FromElement{" );
appendDisplayText( buf );
buf.append( "}" );
return buf.toString();
|
| public org.hibernate.persister.entity.EntityPersister | getEntityPersister()
return elementType.getEntityPersister();
|
| public FromClause | getFromClause()
return fromClause;
|
| public java.lang.String | getIdentityColumn()
checkInitialized();
String table = getTableAlias();
if ( table == null ) {
throw new IllegalStateException( "No table alias for node " + this );
}
String[] cols;
String propertyName;
if ( getEntityPersister() != null && getEntityPersister().getEntityMetamodel() != null
&& getEntityPersister().getEntityMetamodel().hasNonIdentifierPropertyNamedId() ) {
propertyName = getEntityPersister().getIdentifierPropertyName();
}
else {
propertyName = EntityPersister.ENTITY_ID;
}
if ( getWalker().getStatementType() == HqlSqlWalker.SELECT ) {
cols = getPropertyMapping( propertyName ).toColumns( table, propertyName );
}
else {
cols = getPropertyMapping( propertyName ).toColumns( propertyName );
}
String result = StringHelper.join( ", ", cols );
return cols.length == 1 ? result : "(" + result + ")";
|
| public org.hibernate.engine.JoinSequence | getJoinSequence()
return elementType.getJoinSequence();
|
| public org.hibernate.hql.ast.tree.FromElement | getOrigin()
return origin;
|
| public org.hibernate.persister.entity.PropertyMapping | getPropertyMapping(java.lang.String propertyName)
return elementType.getPropertyMapping( propertyName );
|
| public org.hibernate.type.Type | getPropertyType(java.lang.String propertyName, java.lang.String propertyPath)
return elementType.getPropertyType( propertyName, propertyPath );
|
| public org.hibernate.persister.entity.Queryable | getQueryable()
return elementType.getQueryable();
|
| public org.hibernate.persister.collection.QueryableCollection | getQueryableCollection()
return elementType.getQueryableCollection();
|
| public org.hibernate.hql.ast.tree.FromElement | getRealOrigin()
if ( origin == null ) {
return null;
}
if ( origin.getText() == null || "".equals( origin.getText() ) ) {
return origin.getRealOrigin();
}
return origin;
|
| public org.hibernate.type.Type | getSelectType()
return elementType.getSelectType();
|
| public int | getSequence()
return sequence;
|
| public java.lang.String | getTableAlias()
return tableAlias;
|
| private java.lang.String | getTableName()
Queryable queryable = getQueryable();
return ( queryable != null ) ? queryable.getTableName() : "{none}";
|
| public java.lang.String | getWithClauseFragment()
return withClauseFragment;
|
| public java.lang.String | getWithClauseJoinAlias()
return withClauseJoinAlias;
|
| public void | handlePropertyBeingDereferenced(org.hibernate.type.Type propertySource, java.lang.String propertyName)
if ( getQueryableCollection() != null && CollectionProperties.isCollectionProperty( propertyName ) ) {
// propertyName refers to something like collection.size...
return;
}
if ( propertySource.isComponentType() ) {
// property name is a sub-path of a component...
return;
}
Queryable persister = getQueryable();
if ( persister != null ) {
try {
Queryable.Declarer propertyDeclarer = persister.getSubclassPropertyDeclarer( propertyName );
if ( log.isTraceEnabled() ) {
log.trace( "handling property dereference [" + persister.getEntityName() + " (" + getClassAlias() + ") -> " + propertyName + " (" + propertyDeclarer + ")]" );
}
if ( propertyDeclarer == Queryable.Declarer.SUBCLASS ) {
dereferencedBySubclassProperty = true;
includeSubclasses = true;
}
else if ( propertyDeclarer == Queryable.Declarer.SUPERCLASS ) {
dereferencedBySuperclassProperty = true;
}
}
catch( QueryException ignore ) {
// ignore it; the incoming property could not be found so we
// cannot be sure what to do here. At the very least, the
// safest is to simply not apply any dereference toggling...
}
}
|
| public boolean | hasCacheablePersister()
if ( getQueryableCollection() != null ) {
return getQueryableCollection().hasCache();
}
else {
return getQueryable().hasCache();
}
|
| public int | hashCode()
return super.hashCode();
|
| public boolean | inProjectionList()
return !isImplied() && isFromOrJoinFragment();
|
| public void | initializeCollection(FromClause fromClause, java.lang.String classAlias, java.lang.String tableAlias)
doInitialize( fromClause, tableAlias, null, classAlias, null, null );
initialized = true;
|
| public void | initializeEntity(FromClause fromClause, java.lang.String className, org.hibernate.persister.entity.EntityPersister persister, org.hibernate.type.EntityType type, java.lang.String classAlias, java.lang.String tableAlias)
doInitialize( fromClause, tableAlias, className, classAlias, persister, type );
this.sequence = fromClause.nextFromElementCounter();
initialized = true;
|
| public boolean | isAllPropertyFetch()
return isAllPropertyFetch;
|
| public boolean | isCollectionJoin()
return collectionJoin;
|
| public boolean | isCollectionOfValuesOrComponents()
return elementType.isCollectionOfValuesOrComponents();
|
| public boolean | isDereferencedBySubclassProperty()
return dereferencedBySubclassProperty;
|
| public boolean | isDereferencedBySuperclassOrSubclassProperty()
return dereferencedBySubclassProperty || dereferencedBySuperclassProperty;
|
| public boolean | isDereferencedBySuperclassProperty()
return dereferencedBySuperclassProperty;
|
| public boolean | isEntity()
return elementType.isEntity();
|
| public boolean | isFetch()
return fetch;
|
| public boolean | isFilter()
return filter;
|
| public boolean | isFromOrJoinFragment()
return getType() == SqlTokenTypes.FROM_FRAGMENT || getType() == SqlTokenTypes.JOIN_FRAGMENT;
|
| public boolean | isImplied()Returns true if this FromElement was implied by a path, or false if this FROM element is explicitly declared in
the FROM clause.
return false; // This is an explicit FROM element.
|
| public boolean | isImpliedInFromClause()
return false; // Since this is an explicit FROM element, it can't be implied in the FROM clause.
|
| public boolean | isIncludeSubclasses()
return includeSubclasses;
|
| public boolean | isManyToMany()
return manyToMany;
|
| java.lang.String | renderCollectionSelectFragment(int size, int k)
return elementType.renderCollectionSelectFragment( size, k );
|
| java.lang.String | renderIdentifierSelect(int size, int k)Returns the identifier select SQL fragment.
return elementType.renderIdentifierSelect( size, k );
|
| java.lang.String | renderPropertySelect(int size, int k)Returns the property select SQL fragment.
return elementType.renderPropertySelect( size, k, isAllPropertyFetch );
|
| java.lang.String | renderScalarIdentifierSelect(int i)Render the identifier select, but in a 'scalar' context (i.e. generate the column alias).
return elementType.renderScalarIdentifierSelect( i );
|
| java.lang.String | renderValueCollectionSelectFragment(int size, int k)
return elementType.renderValueCollectionSelectFragment( size, k );
|
| public void | setAllPropertyFetch(boolean fetch)
isAllPropertyFetch = fetch;
|
| public void | setCollectionJoin(boolean collectionJoin)
this.collectionJoin = collectionJoin;
|
| public void | setCollectionSuffix(java.lang.String suffix)
elementType.setCollectionSuffix(suffix);
|
| public void | setCollectionTableAlias(java.lang.String collectionTableAlias)
this.collectionTableAlias = collectionTableAlias;
|
| public void | setColumns(java.lang.String[] columns)
this.columns = columns;
|
| public void | setFetch(boolean fetch)
this.fetch = fetch;
// Fetch can't be used with scroll() or iterate().
if ( fetch && getWalker().isShallowQuery() ) {
throw new QueryException( QueryTranslator.ERROR_CANNOT_FETCH_WITH_ITERATE );
}
|
| public void | setFilter(boolean b)
filter = b;
|
| public void | setImpliedInFromClause(boolean flag)
throw new UnsupportedOperationException( "Explicit FROM elements can't be implied in the FROM clause!" );
|
| public void | setInProjectionList(boolean inProjectionList)
// Do nothing, eplicit from elements are *always* in the projection list.
|
| public void | setIncludeSubclasses(boolean includeSubclasses)
if ( isDereferencedBySuperclassOrSubclassProperty() ) {
if ( !includeSubclasses && log.isTraceEnabled() ) {
log.trace( "attempt to disable subclass-inclusions", new Exception( "stack-trace source" ) );
}
}
this.includeSubclasses = includeSubclasses;
|
| public void | setJoinSequence(org.hibernate.engine.JoinSequence joinSequence)
elementType.setJoinSequence( joinSequence );
|
| public void | setOrigin(org.hibernate.hql.ast.tree.FromElement origin, boolean manyToMany)
this.origin = origin;
this.manyToMany = manyToMany;
origin.addDestination( this );
if ( origin.getFromClause() == this.getFromClause() ) {
// TODO: Figure out a better way to get the FROM elements in a proper tree structure.
// If this is not the destination of a many-to-many, add it as a child of the origin.
if ( manyToMany ) {
ASTUtil.appendSibling( origin, this );
}
else {
if ( !getWalker().isInFrom() && !getWalker().isInSelect() ) {
getFromClause().addChild( this );
}
else {
origin.addChild( this );
}
}
}
else if ( !getWalker().isInFrom() ) {
// HHH-276 : implied joins in a subselect where clause - The destination needs to be added
// to the destination's from clause.
getFromClause().addChild( this ); // Not sure if this is will fix everything, but it works.
}
else {
// Otherwise, the destination node was implied by the FROM clause and the FROM clause processor
// will automatically add it in the right place.
}
|
| public void | setQueryableCollection(org.hibernate.persister.collection.QueryableCollection queryableCollection)
elementType.setQueryableCollection( queryableCollection );
|
| public void | setRole(java.lang.String role)
this.role = role;
|
| public void | setUseFromFragment(boolean useFromFragment)
this.useFromFragment = useFromFragment;
|
| public void | setUseWhereFragment(boolean b)
useWhereFragment = b;
|
| public void | setWithClauseFragment(java.lang.String withClauseJoinAlias, java.lang.String withClauseFragment)
this.withClauseJoinAlias = withClauseJoinAlias;
this.withClauseFragment = withClauseFragment;
|
| public java.lang.String[] | toColumns(java.lang.String tableAlias, java.lang.String path, boolean inSelect)
return elementType.toColumns( tableAlias, path, inSelect );
|
| public java.lang.String[] | toColumns(java.lang.String tableAlias, java.lang.String path, boolean inSelect, boolean forceAlias)
return elementType.toColumns( tableAlias, path, inSelect, forceAlias );
|
| public boolean | useFromFragment()
checkInitialized();
// If it's not implied or it is implied and it's a many to many join where the target wasn't found.
return !isImplied() || this.useFromFragment;
|
| public boolean | useWhereFragment()
return useWhereFragment;
|
