public QueryParameters() 
{
	  
		this( ArrayHelper.EMPTY_TYPE_ARRAY, ArrayHelper.EMPTY_OBJECT_ARRAY );
}

 public QueryParameters(Type type,
    Object value) 
{
		this( new Type[] { type }, new Object[] { value } );
}

 public QueryParameters(Type[] positionalParameterTypes,
    Object[] postionalParameterValues) 
{
		this( positionalParameterTypes, postionalParameterValues, null, null, false, null, null, false, null );
}

 public QueryParameters(Type[] positionalParameterTypes,
    Object[] postionalParameterValues,
    Serializable[] collectionKeys) 
{
		this( positionalParameterTypes, postionalParameterValues, null, collectionKeys );
}

 public QueryParameters(Type[] positionalParameterTypes,
    Object[] postionalParameterValues,
    Map namedParameters,
    Serializable[] collectionKeys) 
{
		this(
				positionalParameterTypes,
				postionalParameterValues,
				namedParameters,
				null,
				null,
				false,
				false,
				null,
				null,
				collectionKeys,
				null
		);
}

 public QueryParameters(Type[] positionalParameterTypes,
    Object[] postionalParameterValues,
    Object optionalObject,
    String optionalEntityName,
    Serializable optionalObjectId) 
{
		this( positionalParameterTypes, postionalParameterValues );
		this.optionalObject = optionalObject;
		this.optionalId = optionalObjectId;
		this.optionalEntityName = optionalEntityName;
}

 public QueryParameters(Type[] positionalParameterTypes,
    Object[] positionalParameterValues,
    Map lockModes,
    RowSelection rowSelection,
    boolean cacheable,
    String cacheRegion,
    String comment,
    boolean isLookupByNaturalKey,
    ResultTransformer transformer) 
{
		this(
				positionalParameterTypes,
				positionalParameterValues,
				null,
				lockModes,
				rowSelection,
				false,
				cacheable,
				cacheRegion,
				comment,
				null,
				transformer
		);
		isNaturalKeyLookup = isLookupByNaturalKey;
}

 public QueryParameters(Type[] positionalParameterTypes,
    Object[] positionalParameterValues,
    Map namedParameters,
    Map lockModes,
    RowSelection rowSelection,
    boolean readOnly,
    boolean cacheable,
    String cacheRegion,
    String comment,
    Serializable[] collectionKeys,
    ResultTransformer transformer) 
{
		this.positionalParameterTypes = positionalParameterTypes;
		this.positionalParameterValues = positionalParameterValues;
		this.namedParameters = namedParameters;
		this.lockModes = lockModes;
		this.rowSelection = rowSelection;
		this.cacheable = cacheable;
		this.cacheRegion = cacheRegion;
		//this.forceCacheRefresh = forceCacheRefresh;
		this.comment = comment;
		this.collectionKeys = collectionKeys;
		this.readOnly = readOnly;
		this.resultTransformer = transformer;
}

 public QueryParameters(Type[] positionalParameterTypes,
    Object[] positionalParameterValues,
    Map namedParameters,
    Map lockModes,
    RowSelection rowSelection,
    boolean readOnly,
    boolean cacheable,
    String cacheRegion,
    String comment,
    Serializable[] collectionKeys,
    Object optionalObject,
    String optionalEntityName,
    Serializable optionalId,
    ResultTransformer transformer) 
{
		this(
				positionalParameterTypes,
				positionalParameterValues,
				namedParameters,
				lockModes,
				rowSelection,
				readOnly,
				cacheable,
				cacheRegion,
				comment,
				collectionKeys,
				transformer
		);
		this.optionalEntityName = optionalEntityName;
		this.optionalId = optionalId;
		this.optionalObject = optionalObject;
}

 public QueryParameters createCopyUsing(RowSelection selection) 
{
		QueryParameters copy = new QueryParameters(
				this.positionalParameterTypes,
				this.positionalParameterValues,
				this.namedParameters,
				this.lockModes,
				selection,
				this.readOnly,
				this.cacheable,
				this.cacheRegion,
				this.comment,
				this.collectionKeys,
				this.optionalObject,
				this.optionalEntityName,
				this.optionalId,
				this.resultTransformer
		);
		copy.processedSQL = this.processedSQL;
		copy.processedPositionalParameterTypes = this.processedPositionalParameterTypes;
		copy.processedPositionalParameterValues = this.processedPositionalParameterValues;
		return copy;
}

 public String getCacheRegion() 
{
		return cacheRegion;
}

 public Serializable[] getCollectionKeys() 
{
		return collectionKeys;
}

 public String getComment() 
{
		return comment;
}

 public Type[] getFilteredPositionalParameterTypes() 
{
		return processedPositionalParameterTypes;
}

 public Object[] getFilteredPositionalParameterValues() 
{
		return processedPositionalParameterValues;
}

 public String getFilteredSQL() 
{
		return processedSQL;
}

 public Map getLockModes() 
{
		return lockModes;
}

 public Map getNamedParameters() 
{
		return namedParameters;
}

 public String getOptionalEntityName() 
{
		return optionalEntityName;
}

 public Serializable getOptionalId() 
{
		return optionalId;
}

 public Object getOptionalObject() 
{
		return optionalObject;
}

 public Type[] getPositionalParameterTypes() 
{
		return positionalParameterTypes;
}

 public Object[] getPositionalParameterValues() 
{
		return positionalParameterValues;
}

 public ResultTransformer getResultTransformer() 
{
		return resultTransformer;
}

 public RowSelection getRowSelection() 
{
		return rowSelection;
}

 public ScrollMode getScrollMode() 
{
		return scrollMode;
}

 public boolean hasAutoDiscoverScalarTypes() 
{
		return autodiscovertypes;
}

 public boolean hasRowSelection() 
{
		return rowSelection != null;
}

 public boolean isCacheable() 
{
		return cacheable;
}

 public boolean isCallable() 
{
		return callable;
}

 public boolean isNaturalKeyLookup() 
{
		return isNaturalKeyLookup;
}

 public boolean isReadOnly() 
{
		return readOnly;
}

 public  void processFilters(String sql,
    SessionImplementor session) 
{
		processFilters( sql, session.getLoadQueryInfluencers().getEnabledFilters(), session.getFactory() );
}

 public  void processFilters(String sql,
    Map filters,
    SessionFactoryImplementor factory) 
{
		if ( filters.size() == 0 || sql.indexOf( ParserHelper.HQL_VARIABLE_PREFIX ) <  0 ) {
			// HELLA IMPORTANT OPTIMIZATION!!!
			processedPositionalParameterValues = getPositionalParameterValues();
			processedPositionalParameterTypes = getPositionalParameterTypes();
			processedSQL = sql;
		}
		else {
			final Dialect dialect = factory.getDialect();
			String symbols = new StringBuffer().append( ParserHelper.HQL_SEPARATORS )
					.append( dialect.openQuote() )
					.append( dialect.closeQuote() )
					.toString();
			StringTokenizer tokens = new StringTokenizer( sql, symbols, true );
			StringBuffer result = new StringBuffer();
			List parameters = new ArrayList();
			List parameterTypes = new ArrayList();
			int positionalIndex = 0;
			while ( tokens.hasMoreTokens() ) {
				final String token = tokens.nextToken();
				if ( token.startsWith( ParserHelper.HQL_VARIABLE_PREFIX ) ) {
					final String filterParameterName = token.substring( 1 );
					final String[] parts = LoadQueryInfluencers.parseFilterParameterName( filterParameterName );
					final FilterImpl filter = ( FilterImpl ) filters.get( parts[0] );
					final Object value = filter.getParameter( parts[1] );
					final Type type = filter.getFilterDefinition().getParameterType( parts[1] );
					if ( value != null && Collection.class.isAssignableFrom( value.getClass() ) ) {
						Iterator itr = ( ( Collection ) value ).iterator();
						while ( itr.hasNext() ) {
							Object elementValue = itr.next();
							result.append( '?" );
							parameters.add( elementValue );
							parameterTypes.add( type );
							if ( itr.hasNext() ) {
								result.append( ", " );
							}
						}
					}
					else {
						result.append( '?" );
						parameters.add( value );
						parameterTypes.add( type );
					}
				}
				else {
					if ( "?".equals( token ) && positionalIndex <  getPositionalParameterValues().length ) {
						parameters.add( getPositionalParameterValues()[positionalIndex] );
						parameterTypes.add( getPositionalParameterTypes()[positionalIndex] );
						positionalIndex++;
					}
					result.append( token );
				}
			}
			processedPositionalParameterValues = parameters.toArray();
			processedPositionalParameterTypes = ( Type[] ) parameterTypes.toArray( new Type[parameterTypes.size()] );
			processedSQL = result.toString();
		}
}

 public  void setAutoDiscoverScalarTypes(boolean autodiscovertypes) 
{
		this.autodiscovertypes = autodiscovertypes;
}

 public  void setCacheRegion(String cacheRegion) 
{
		this.cacheRegion = cacheRegion;
}

 public  void setCacheable(boolean b) 
{
		cacheable = b;
}

 public  void setCallable(boolean callable) 
{
		this.callable = callable;
}

 public  void setCollectionKeys(Serializable[] collectionKeys) 
{
		this.collectionKeys = collectionKeys;
}

 public  void setComment(String comment) 
{
		this.comment = comment;
}

 public  void setLockModes(Map map) 
{
		lockModes = map;
}

 public  void setNamedParameters(Map map) 
{
		namedParameters = map;
}

 public  void setNaturalKeyLookup(boolean isNaturalKeyLookup) 
{
		this.isNaturalKeyLookup = isNaturalKeyLookup;
}

 public  void setOptionalEntityName(String optionalEntityName) 
{
		this.optionalEntityName = optionalEntityName;
}

 public  void setOptionalId(Serializable optionalId) 
{
		this.optionalId = optionalId;
}

 public  void setOptionalObject(Object optionalObject) 
{
		this.optionalObject = optionalObject;
}

 public  void setPositionalParameterTypes(Type[] types) 
{
		positionalParameterTypes = types;
}

 public  void setPositionalParameterValues(Object[] objects) 
{
		positionalParameterValues = objects;
}

 public  void setReadOnly(boolean readOnly) 
{
		this.readOnly = readOnly;
}

 public  void setRowSelection(RowSelection selection) 
{
		rowSelection = selection;
}

 public  void setScrollMode(ScrollMode scrollMode) 
{
		this.scrollMode = scrollMode;
}

 public  void traceParameters(SessionFactoryImplementor factory) throws HibernateException 
{
		Printer print = new Printer( factory );
		if ( positionalParameterValues.length != 0 ) {
			log.trace(
					"parameters: " +
							print.toString( positionalParameterTypes, positionalParameterValues )
			);
		}
		if ( namedParameters != null ) {
			log.trace( "named parameters: " + print.toString( namedParameters ) );
		}
}

 public  void validateParameters() throws QueryException 
{
		int types = positionalParameterTypes == null ? 0 : positionalParameterTypes.length;
		int values = positionalParameterValues == null ? 0 : positionalParameterValues.length;
		if ( types != values ) {
			throw new QueryException(
					"Number of positional parameter types:" + types +
							" does not match number of positional parameters: " + values
			);
		}
}