criteriaquerytranslator.java

介绍了hibernate的入门有一些基本常用的事例

			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(),
			//criteria.isForceCacheRefresh(),
			rootCriteria.getComment()
		);
	}
	
	public boolean hasProjection() {
		return rootCriteria.getProjection()!=null;
	}
	
	public String getGroupBy() {
		/*String[] aliases = rootCriteria.getProjection().getGroupColumnAliases(0);
		return StringHelper.join(", ", aliases);*/
		if ( rootCriteria.getProjection().isGrouped() ) {
			return rootCriteria.getProjection()
				.toGroupSqlString( rootCriteria.getProjectionCriteria(), this );
		}
		else {
			return "";
		}
	}
	
	public String getSelect() {
		return rootCriteria.getProjection().toSqlString(
				rootCriteria.getProjectionCriteria(), 
				0, 
				this
		);
	}
	
	public Type[] getProjectedTypes() {
		return rootCriteria.getProjection().getTypes(rootCriteria, this);
	}

	public String[] getProjectedColumnAliases() {
		return rootCriteria.getProjection().getColumnAliases(0);
	}
	
	public String[] getProjectedAliases() {
		return rootCriteria.getProjection().getAliases();
	}
	
	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 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 SessionFactoryImplementor getFactory() {
		return sessionFactory;
	}
	
	public String getSQLAlias(Criteria criteria) {
		return (String) criteriaSQLAliasMap.get(criteria);
	}
	
	public String getEntityName(Criteria criteria) {
		return (String) criteriaEntityNames.get(criteria);
	}
	
	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];
	}

	/**
	 * Get the names of the columns constrained
	 * by this criterion.
	 */
	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;
		}
	}
	
	public String[] getIdentifierColumns(Criteria subcriteria) {
		String[] idcols = ( (Loadable) getPropertyMapping( getEntityName(subcriteria) ) ).getIdentifierColumnNames();
		return StringHelper.qualify( getSQLAlias(subcriteria), idcols );
	}
	
	public TypedValue getTypedIdentifierValue(Criteria subcriteria, Object value) {
		final Loadable loadable = (Loadable) getPropertyMapping( getEntityName(subcriteria) );
		return new TypedValue( 
				loadable.getIdentifierType(),
				value,
				EntityMode.POJO
			);
	}
	
	private String[] getColumns(String propertyName, Criteria subcriteria)
	throws HibernateException {
		return getPropertyMapping( getEntityName(subcriteria, propertyName) )
			.toColumns( getSQLAlias(subcriteria, propertyName), 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 Type getType(Criteria subcriteria, String propertyName)
	throws HibernateException {
		return getPropertyMapping( getEntityName(subcriteria, propertyName) )
			.toType( getPropertyName(propertyName) );
	}

	/**
	 * Get the a typed value for the given property value.
	 */
	public TypedValue getTypedValue(Criteria subcriteria, String propertyName, Object value)
	throws HibernateException {
		return new TypedValue( 
				getTypeUsingProjection(subcriteria, propertyName), 
				value, 
				EntityMode.POJO 
			);
	}

	private PropertyMapping getPropertyMapping(String entityName)
	throws MappingException {
		return (PropertyMapping) sessionFactory.getEntityPersister(entityName);
	}
	
	//TODO: use these in methods above

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

}