public CriteriaQueryTranslator(SessionFactoryImplementor factory,
    CriteriaImpl criteria,
    String rootEntityName,
    String rootSQLAlias) throws HibernateException 
{
		this.rootCriteria = criteria;
		this.rootEntityName = rootEntityName;
		this.sessionFactory = factory;
		this.rootSQLAlias = rootSQLAlias;
		createAliasCriteriaMap();
		createAssociationPathCriteriaMap();
		createCriteriaEntityNameMap();
		createCriteriaSQLAliasMap();
}

 public CriteriaQueryTranslator(SessionFactoryImplementor factory,
    CriteriaImpl criteria,
    String rootEntityName,
    String rootSQLAlias,
    CriteriaQuery outerQuery) throws HibernateException 
{
	 
		this( factory, criteria, rootEntityName, rootSQLAlias );
		outerQueryTranslator = outerQuery;
}

 public String generateSQLAlias() 
{
		return StringHelper.generateAlias( Criteria.ROOT_ALIAS, aliasCount ) + '_";
}

 public String getColumn(Criteria criteria,
    String propertyName) 
{
		String[] cols = getColumns( propertyName, criteria );
		if ( cols.length != 1 ) {
			throw new QueryException( "property does not map to a single column: " + propertyName );
		}
		return cols[0];
}

 public String[] getColumnsUsingProjection(Criteria subcriteria,
    String propertyName) throws HibernateException 
{
		//first look for a reference to a projection alias
		final Projection projection = rootCriteria.getProjection();
		String[] projectionColumns = projection == null ?
		                             null :
		                             projection.getColumnAliases( propertyName, 0 );
		if ( projectionColumns == null ) {
			//it does not refer to an alias of a projection,
			//look for a property
			try {
				return getColumns( propertyName, subcriteria );
			}
			catch ( HibernateException he ) {
				//not found in inner query , try the outer query
				if ( outerQueryTranslator != null ) {
					return outerQueryTranslator.getColumnsUsingProjection( subcriteria, propertyName );
				}
				else {
					throw he;
				}
			}
		}
		else {
			//it refers to an alias of a projection
			return projectionColumns;
		}
}

Get the names of the columns constrained by this criterion.

 public Criteria getCriteria(String path) 
{
		return ( Criteria ) associationPathCriteriaMap.get( path );
}

 public String getEntityName(Criteria criteria) 
{
		return ( String ) criteriaEntityNames.get( criteria );
}

 public String getEntityName(Criteria subcriteria,
    String propertyName) 
{
		if ( propertyName.indexOf( '." )  > 0 ) {
			String root = StringHelper.root( propertyName );
			Criteria crit = getAliasedCriteria( root );
			if ( crit != null ) {
				return getEntityName( crit );
			}
		}
		return getEntityName( subcriteria );
}

 public SessionFactoryImplementor getFactory() 
{
		return sessionFactory;
}

 public String getGroupBy() 
{
		if ( rootCriteria.getProjection().isGrouped() ) {
			return rootCriteria.getProjection()
					.toGroupSqlString( rootCriteria.getProjectionCriteria(), this );
		}
		else {
			return "";
		}
}

 public String[] getIdentifierColumns(Criteria subcriteria) 
{
		String[] idcols =
				( ( Loadable ) getPropertyMapping( getEntityName( subcriteria ) ) ).getIdentifierColumnNames();
		return StringHelper.qualify( getSQLAlias( subcriteria ), idcols );
}

 public Type getIdentifierType(Criteria subcriteria) 
{
		return ( ( Loadable ) getPropertyMapping( getEntityName( subcriteria ) ) ).getIdentifierType();
}

 public int getJoinType(String path) 
{
		Integer result = ( Integer ) associationPathJoinTypesMap.get( path );
		return ( result == null ? Criteria.INNER_JOIN : result.intValue() );
}

 public String getOrderBy() 
{
		StringBuffer orderBy = new StringBuffer( 30 );
		Iterator criterionIterator = rootCriteria.iterateOrderings();
		while ( criterionIterator.hasNext() ) {
			CriteriaImpl.OrderEntry oe = ( CriteriaImpl.OrderEntry ) criterionIterator.next();
			orderBy.append( oe.getOrder().toSqlString( oe.getCriteria(), this ) );
			if ( criterionIterator.hasNext() ) {
				orderBy.append( ", " );
			}
		}
		return orderBy.toString();
}

 public String[] getProjectedAliases() 
{
		return rootCriteria.getProjection().getAliases();
}

 public String[] getProjectedColumnAliases() 
{
		return rootCriteria.getProjection().getColumnAliases( 0 );
}

 public Type[] getProjectedTypes() 
{
		return rootCriteria.getProjection().getTypes( rootCriteria, this );
}

 public String getPropertyName(String propertyName) 
{
		if ( propertyName.indexOf( '." )  > 0 ) {
			String root = StringHelper.root( propertyName );
			Criteria crit = getAliasedCriteria( root );
			if ( crit != null ) {
				return propertyName.substring( root.length() + 1 );
			}
		}
		return propertyName;
}

 public QueryParameters getQueryParameters() 
{
		List values = new ArrayList();
		List types = new ArrayList();
		Iterator iter = rootCriteria.iterateExpressionEntries();
		while ( iter.hasNext() ) {
			CriteriaImpl.CriterionEntry ce = ( CriteriaImpl.CriterionEntry ) iter.next();
			TypedValue[] tv = ce.getCriterion().getTypedValues( ce.getCriteria(), this );
			for ( int i = 0; i <  tv.length; i++ ) {
				values.add( tv[i].getValue() );
				types.add( tv[i].getType() );
			}
		}
		Object[] valueArray = values.toArray();
		Type[] typeArray = ArrayHelper.toTypeArray( types );
		RowSelection selection = new RowSelection();
		selection.setFirstRow( rootCriteria.getFirstResult() );
		selection.setMaxRows( rootCriteria.getMaxResults() );
		selection.setTimeout( rootCriteria.getTimeout() );
		selection.setFetchSize( rootCriteria.getFetchSize() );
		Map lockModes = new HashMap();
		iter = rootCriteria.getLockModes().entrySet().iterator();
		while ( iter.hasNext() ) {
			Map.Entry me = ( Map.Entry ) iter.next();
			final Criteria subcriteria = getAliasedCriteria( ( String ) me.getKey() );
			lockModes.put( getSQLAlias( subcriteria ), me.getValue() );
		}
		iter = rootCriteria.iterateSubcriteria();
		while ( iter.hasNext() ) {
			CriteriaImpl.Subcriteria subcriteria = ( CriteriaImpl.Subcriteria ) iter.next();
			LockMode lm = subcriteria.getLockMode();
			if ( lm != null ) {
				lockModes.put( getSQLAlias( subcriteria ), lm );
			}
		}
		return new QueryParameters(
				typeArray,
		        valueArray,
		        lockModes,
		        selection,
		        rootCriteria.getCacheable(),
		        rootCriteria.getCacheRegion(),
		        rootCriteria.getComment(),
		        rootCriteria.isLookupByNaturalKey(),
		        rootCriteria.getResultTransformer()
		);
}

 public Set getQuerySpaces() 
{
		Set result = new HashSet();
		Iterator iter = criteriaEntityNames.values().iterator();
		while ( iter.hasNext() ) {
			String entityName = ( String ) iter.next();
			result.addAll( Arrays.asList( getFactory().getEntityPersister( entityName ).getQuerySpaces() ) );
		}
		return result;
}

 public CriteriaImpl getRootCriteria() 
{
		return rootCriteria;
}

 public String getRootSQLALias() 
{
		return rootSQLAlias;
}

 public String getSQLAlias(Criteria criteria) 
{
		return ( String ) criteriaSQLAliasMap.get( criteria );
}

 public String getSQLAlias(Criteria criteria,
    String propertyName) 
{
		if ( propertyName.indexOf( '." )  > 0 ) {
			String root = StringHelper.root( propertyName );
			Criteria subcriteria = getAliasedCriteria( root );
			if ( subcriteria != null ) {
				return getSQLAlias( subcriteria );
			}
		}
		return getSQLAlias( criteria );
}

 public int getSQLAliasCount() 
{
		return criteriaSQLAliasMap.size();
}

 public String getSelect() 
{
		return rootCriteria.getProjection().toSqlString(
				rootCriteria.getProjectionCriteria(),
		        0,
		        this
		);
}

 public Type getType(Criteria subcriteria,
    String propertyName) throws HibernateException 
{
		return getPropertyMapping( getEntityName( subcriteria, propertyName ) )
				.toType( getPropertyName( propertyName ) );
}

 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];
		}
}

 public TypedValue getTypedIdentifierValue(Criteria subcriteria,
    Object value) 
{
		final Loadable loadable = ( Loadable ) getPropertyMapping( getEntityName( subcriteria ) );
		return new TypedValue(
				loadable.getIdentifierType(),
		        value,
		        EntityMode.POJO
		);
}

 public TypedValue getTypedValue(Criteria subcriteria,
    String propertyName,
    Object value) throws HibernateException 
{
		// Detect discriminator values...
		if ( value instanceof Class ) {
			Class entityClass = ( Class ) value;
			Queryable q = SessionFactoryHelper.findQueryableUsingImports( sessionFactory, entityClass.getName() );
			if ( q != null ) {
				Type type = q.getDiscriminatorType();
				String stringValue = q.getDiscriminatorSQLValue();
				// Convert the string value into the proper type.
				if ( type instanceof NullableType ) {
					NullableType nullableType = ( NullableType ) type;
					value = nullableType.fromStringValue( stringValue );
				}
				else {
					throw new QueryException( "Unsupported discriminator type " + type );
				}
				return new TypedValue(
						type,
				        value,
				        EntityMode.POJO
				);
			}
		}
		// Otherwise, this is an ordinary value.
		return new TypedValue(
				getTypeUsingProjection( subcriteria, propertyName ),
		        value,
		        EntityMode.POJO
		);
}

Get the a typed value for the given property value.

 public String getWhereCondition() 
{
		StringBuffer condition = new StringBuffer( 30 );
		Iterator criterionIterator = rootCriteria.iterateExpressionEntries();
		while ( criterionIterator.hasNext() ) {
			CriteriaImpl.CriterionEntry entry = ( CriteriaImpl.CriterionEntry ) criterionIterator.next();
			String sqlString = entry.getCriterion().toSqlString( entry.getCriteria(), this );
			condition.append( sqlString );
			if ( criterionIterator.hasNext() ) {
				condition.append( " and " );
			}
		}
		return condition.toString();
}

 public boolean hasProjection() 
{
		return rootCriteria.getProjection() != null;
}

 public boolean isJoin(String path) 
{
		return associationPathCriteriaMap.containsKey( path );
}