SQLQueryImpl(NamedSQLQueryDefinition queryDef,
    SessionImplementor session,
    ParameterMetadata parameterMetadata) 
{
		super( queryDef.getQueryString(), queryDef.getFlushMode(), session, parameterMetadata );
		if ( queryDef.getResultSetRef() != null ) {
			ResultSetMappingDefinition definition = session.getFactory()
					.getResultSetMapping( queryDef.getResultSetRef() );
			if (definition == null) {
				throw new MappingException(
						"Unable to find resultset-ref definition: " +
						queryDef.getResultSetRef()
					);
			}
			this.queryReturns = Arrays.asList( definition.getQueryReturns() );
		}
		else {
			this.queryReturns = Arrays.asList( queryDef.getQueryReturns() );
		}
		this.querySpaces = queryDef.getQuerySpaces();
		this.callable = queryDef.isCallable();
}

Constructs a SQLQueryImpl given a sql query defined in the mappings.

Parameters:

queryDef - The representation of the defined .

session - The session to which this SQLQueryImpl belongs.

parameterMetadata - Metadata about parameters found in the query.

 SQLQueryImpl(String sql,
    SessionImplementor session,
    ParameterMetadata parameterMetadata) 
{
		super( sql, null, session, parameterMetadata );
		queryReturns = new ArrayList();
		querySpaces = null;
		callable = false;
}

 SQLQueryImpl(String sql,
    String[] returnAliases,
    Class[] returnClasses,
    SessionImplementor session,
    ParameterMetadata parameterMetadata) 
{
		this( sql, returnAliases, returnClasses, null, session, null, null, parameterMetadata );
}

 SQLQueryImpl(String sql,
    List queryReturns,
    Collection querySpaces,
    FlushMode flushMode,
    boolean callable,
    SessionImplementor session,
    ParameterMetadata parameterMetadata) 
{
		// TODO : absolutely no usages of this constructor form; can it go away?
		super( sql, flushMode, session, parameterMetadata );
		this.queryReturns = queryReturns;
		this.querySpaces = querySpaces;
		this.callable = callable;
}

 SQLQueryImpl(String sql,
    String[] returnAliases,
    Class[] returnClasses,
    LockMode[] lockModes,
    SessionImplementor session,
    Collection querySpaces,
    FlushMode flushMode,
    ParameterMetadata parameterMetadata) 
{
		// TODO : this constructor form is *only* used from constructor directly below us; can it go away?
		super( sql, flushMode, session, parameterMetadata );
		queryReturns = new ArrayList(returnAliases.length);
		for ( int i=0; i< returnAliases.length; i++ ) {
			NativeSQLQueryRootReturn ret = new NativeSQLQueryRootReturn(
					returnAliases[i],
					returnClasses[i].getName(),
					lockModes==null ? LockMode.NONE : lockModes[i]
			);
			queryReturns.add(ret);
		}
		this.querySpaces = querySpaces;
		this.callable = false;
}

 public SQLQuery addEntity(Class entityClass) 
{
		return addEntity( StringHelper.unqualify( entityClass.getName() ), entityClass );
}

 public SQLQuery addEntity(String entityName) 
{
		return addEntity( StringHelper.unqualify( entityName ), entityName );
}

 public SQLQuery addEntity(String alias,
    String entityName) 
{
		return addEntity(alias, entityName, LockMode.READ);
}

 public SQLQuery addEntity(String alias,
    Class entityClass) 
{
		return addEntity( alias, entityClass.getName() );
}

 public SQLQuery addEntity(String alias,
    String entityName,
    LockMode lockMode) 
{
		queryReturns.add( new NativeSQLQueryRootReturn(alias, entityName, lockMode) );
		return this;
}

 public SQLQuery addEntity(String alias,
    Class entityClass,
    LockMode lockMode) 
{
		return addEntity( alias, entityClass.getName(), lockMode );
}

 public SQLQuery addJoin(String alias,
    String path) 
{
		return addJoin(alias, path, LockMode.READ);
}

 public SQLQuery addJoin(String alias,
    String path,
    LockMode lockMode) 
{
		int loc = path.indexOf('.");
		if ( loc <  0 ) {
			throw new QueryException( "not a property path: " + path );
		}
		String ownerAlias = path.substring(0, loc);
		String role = path.substring(loc+1);
		queryReturns.add( new NativeSQLQueryJoinReturn(alias, ownerAlias, role, CollectionHelper.EMPTY_MAP, lockMode) );
		return this;
}

 public SQLQuery addScalar(String columnAlias) 
{
		autodiscovertypes = true;
		queryReturns.add( new NativeSQLQueryScalarReturn( columnAlias, null ) );
		return this;
}

 public SQLQuery addScalar(String columnAlias,
    Type type) 
{
		queryReturns.add( new NativeSQLQueryScalarReturn( columnAlias, type ) );
		return this;
}

 public SQLQuery addSynchronizedEntityClass(Class entityClass) 
{
		return addQuerySpaces( getSession().getFactory().getEntityPersister( entityClass.getName() ).getQuerySpaces() );
}

 public SQLQuery addSynchronizedEntityName(String entityName) 
{
		return addQuerySpaces( getSession().getFactory().getEntityPersister( entityName ).getQuerySpaces() );
}

 public SQLQuery addSynchronizedQuerySpace(String querySpace) 
{
		if ( querySpaces == null ) {
			querySpaces = new ArrayList();
		}
		querySpaces.add( querySpace );
		return this;
}

 public int executeUpdate() throws HibernateException 
{
		Map namedParams = getNamedParams();
		before();
		try {
			return getSession().executeNativeUpdate(
					generateQuerySpecification( namedParams ),
					getQueryParameters( namedParams )
			);
		}
		finally {
			after();
		}
}

 protected Map getLockModes() 
{
		//we never need to apply locks to the SQL
		return CollectionHelper.EMPTY_MAP;
}

 public QueryParameters getQueryParameters(Map namedParams) 
{
		QueryParameters qp = super.getQueryParameters(namedParams);
		qp.setCallable(callable);
		qp.setAutoDiscoverScalarTypes(autodiscovertypes);
		return qp;
}

 public String[] getReturnAliases() throws HibernateException 
{
		throw new UnsupportedOperationException("SQL queries do not currently support returning aliases");
}

 public Type[] getReturnTypes() throws HibernateException 
{
		throw new UnsupportedOperationException("not yet implemented for SQL queries");
}

 public Iterator iterate() throws HibernateException 
{
		throw new UnsupportedOperationException("SQL queries do not currently support iteration");
}

 public List list() throws HibernateException 
{
		verifyParameters();
		before();
		Map namedParams = getNamedParams();
		NativeSQLQuerySpecification spec = generateQuerySpecification( namedParams );
		try {
			return getSession().list( spec, getQueryParameters( namedParams ) );
		}
		finally {
			after();
		}
}

 public ScrollableResults scroll() throws HibernateException 
{
		return scroll(ScrollMode.SCROLL_INSENSITIVE);
}

 public ScrollableResults scroll(ScrollMode scrollMode) throws HibernateException 
{
		verifyParameters();
		before();
		Map namedParams = getNamedParams();
		NativeSQLQuerySpecification spec = generateQuerySpecification( namedParams );
		QueryParameters qp = getQueryParameters( namedParams );
		qp.setScrollMode( scrollMode );
		try {
			return getSession().scroll( spec, qp );
		}
		finally {
			after();
		}
}

 public Query setLockMode(String alias,
    LockMode lockMode) 
{
		throw new UnsupportedOperationException("cannot set the lock mode for a native SQL query");
}

 public SQLQuery setResultSetMapping(String name) 
{
		ResultSetMappingDefinition mapping = session.getFactory().getResultSetMapping( name );
		if ( mapping == null ) {
			throw new MappingException( "Unknown SqlResultSetMapping [" + name + "]" );
		}
		NativeSQLQueryReturn[] returns = mapping.getQueryReturns();
		int length = returns.length;
		for ( int index = 0 ; index <  length ; index++ ) {
			queryReturns.add( returns[index] );
		}
		return this;
}

 protected  void verifyParameters() 
{
		verifyParameters( callable );
		boolean noReturns = queryReturns==null || queryReturns.isEmpty();
		if ( noReturns ) {
			this.autodiscovertypes = noReturns;
		}
		else {
			Iterator itr = queryReturns.iterator();
			while ( itr.hasNext() ) {
				NativeSQLQueryReturn rtn = ( NativeSQLQueryReturn ) itr.next();
				if ( rtn instanceof NativeSQLQueryScalarReturn ) {
					NativeSQLQueryScalarReturn scalar = ( NativeSQLQueryScalarReturn ) rtn;
					if ( scalar.getType() == null ) {
						autodiscovertypes = true;
						break;
					}
				}
			}
		}
}