private NamedNativeQueries getNamedNativeQueries(
		Element tree,
		XMLContext.Default defaults) {
	List<NamedNativeQuery> queries = (List<NamedNativeQuery>) buildNamedQueries( tree, true, defaults, classLoaderAccess );
	if ( defaults.canUseJavaAnnotations() ) {
		NamedNativeQuery annotation = getPhysicalAnnotation( NamedNativeQuery.class );
		addNamedNativeQueryIfNeeded( annotation, queries );
		NamedNativeQueries annotations = getPhysicalAnnotation( NamedNativeQueries.class );
		if ( annotations != null ) {
			for ( NamedNativeQuery current : annotations.value() ) {
				addNamedNativeQueryIfNeeded( current, queries );
			}
		}
	}
	if ( queries.size() > 0 ) {
		AnnotationDescriptor ad = new AnnotationDescriptor( NamedNativeQueries.class );
		ad.setValue( "value", queries.toArray( new NamedNativeQuery[queries.size()] ) );
		return AnnotationFactory.create( ad );
	}
	else {
		return null;
	}
}
 

private void addNamedNativeQueryIfNeeded(NamedNativeQuery annotation, List<NamedNativeQuery> queries) {
	if ( annotation != null ) {
		String queryName = annotation.name();
		boolean present = false;
		for ( NamedNativeQuery current : queries ) {
			if ( current.name().equals( queryName ) ) {
				present = true;
				break;
			}
		}
		if ( !present ) {
			queries.add( annotation );
		}
	}
}
 

public static void bindNativeQueries(
		NamedNativeQueries queriesAnn,
		MetadataBuildingContext context,
		boolean isDefault) {
	if ( queriesAnn == null ) {
		return;
	}

	for (NamedNativeQuery q : queriesAnn.value()) {
		bindNativeQuery( q, context, isDefault );
	}
}
 

public static void bindNativeQueries(
		org.hibernate.annotations.NamedNativeQueries queriesAnn,
		MetadataBuildingContext context) {
	if ( queriesAnn == null ) {
		return;
	}

	for (org.hibernate.annotations.NamedNativeQuery q : queriesAnn.value()) {
		bindNativeQuery( q, context );
	}
}
 

public static void bindNativeQuery(
		org.hibernate.annotations.NamedNativeQuery queryAnn,
		MetadataBuildingContext context) {
	if ( queryAnn == null ) {
		return;
	}

	//ResultSetMappingDefinition mappingDefinition = mappings.getResultSetMapping( queryAnn.resultSetMapping() );
	if ( BinderHelper.isEmptyAnnotationValue( queryAnn.name() ) ) {
		throw new AnnotationException( "A named query must have a name when used in class or package level" );
	}

	NamedSQLQueryDefinition query;
	String resultSetMapping = queryAnn.resultSetMapping();
	if ( !BinderHelper.isEmptyAnnotationValue( resultSetMapping ) ) {
		//sql result set usage
		query = new NamedSQLQueryDefinitionBuilder().setName( queryAnn.name() )
				.setQuery( queryAnn.query() )
				.setResultSetRef( resultSetMapping )
				.setQuerySpaces( null )
				.setCacheable( queryAnn.cacheable() )
				.setCacheRegion(
						BinderHelper.isEmptyAnnotationValue( queryAnn.cacheRegion() ) ?
								null :
								queryAnn.cacheRegion()
				)
				.setTimeout( queryAnn.timeout() < 0 ? null : queryAnn.timeout() )
				.setFetchSize( queryAnn.fetchSize() < 0 ? null : queryAnn.fetchSize() )
				.setFlushMode( getFlushMode( queryAnn.flushMode() ) )
				.setCacheMode( getCacheMode( queryAnn.cacheMode() ) )
				.setReadOnly( queryAnn.readOnly() )
				.setComment( BinderHelper.isEmptyAnnotationValue( queryAnn.comment() ) ? null : queryAnn.comment() )
				.setParameterTypes( null )
				.setCallable( queryAnn.callable() )
				.createNamedQueryDefinition();
	}
	else if ( !void.class.equals( queryAnn.resultClass() ) ) {
		//class mapping usage
		//FIXME should be done in a second pass due to entity name?
		final NativeSQLQueryRootReturn entityQueryReturn =
				new NativeSQLQueryRootReturn( "alias1", queryAnn.resultClass().getName(), new HashMap(), LockMode.READ );
		query = new NamedSQLQueryDefinitionBuilder().setName( queryAnn.name() )
				.setQuery( queryAnn.query() )
				.setQueryReturns( new NativeSQLQueryReturn[] {entityQueryReturn} )
				.setQuerySpaces( null )
				.setCacheable( queryAnn.cacheable() )
				.setCacheRegion(
						BinderHelper.isEmptyAnnotationValue( queryAnn.cacheRegion() ) ?
								null :
								queryAnn.cacheRegion()
				)
				.setTimeout( queryAnn.timeout() < 0 ? null : queryAnn.timeout() )
				.setFetchSize( queryAnn.fetchSize() < 0 ? null : queryAnn.fetchSize() )
				.setFlushMode( getFlushMode( queryAnn.flushMode() ) )
				.setCacheMode( getCacheMode( queryAnn.cacheMode() ) )
				.setReadOnly( queryAnn.readOnly() )
				.setComment( BinderHelper.isEmptyAnnotationValue( queryAnn.comment() ) ? null : queryAnn.comment() )
				.setParameterTypes( null )
				.setCallable( queryAnn.callable() )
				.createNamedQueryDefinition();
	}
	else {
		throw new NotYetImplementedException( "Pure native scalar queries are not yet supported" );
	}
	context.getMetadataCollector().addNamedNativeQuery( query );
	if ( LOG.isDebugEnabled() ) {
		LOG.debugf( "Binding named native query: %s => %s", query.getName(), queryAnn.query() );
	}
}