org.hibernate.engine.spi.NamedQueryDefinition Java Examples

protected  <T> QueryImplementor<T> buildQueryFromName(String name, Class<T> resultType) {
	checkOpen();
	try {
		checkTransactionSynchStatus();
		delayedAfterCompletion();

		// todo : apply stored setting at the JPA Query level too

		final NamedQueryDefinition namedQueryDefinition = getFactory().getNamedQueryRepository().getNamedQueryDefinition( name );
		if ( namedQueryDefinition != null ) {
			return createQuery( namedQueryDefinition, resultType );
		}

		final NamedSQLQueryDefinition nativeQueryDefinition = getFactory().getNamedQueryRepository().getNamedSQLQueryDefinition( name );
		if ( nativeQueryDefinition != null ) {
			return (QueryImplementor<T>) createNativeQuery( nativeQueryDefinition, resultType );
		}

		throw exceptionConverter.convert( new IllegalArgumentException( "No query defined for that name [" + name + "]" ) );
	}
	catch (RuntimeException e) {
		throw !( e instanceof IllegalArgumentException ) ? new IllegalArgumentException( e ) : e;
	}
}
 

/**
 * 根据hql创建Hibernate Query对象
 * 
 * @param queryOrNamedQuery hql 或者Hibernate的NamedQuery
 * @param values
 *            数量可变的参数,按顺序绑定.
 *            
 * @return {@link Query}
 */
protected Query createQuery(String queryOrNamedQuery, Object... values) {
	Assert.hasText(queryOrNamedQuery, "queryOrNamedQuery不能为空");
	
	SessionFactoryImpl factory = (SessionFactoryImpl) sessionFactory;
	NamedQueryDefinition nqd = factory.getNamedQuery( queryOrNamedQuery );
	Query query = null;
	
	if (nqd != null) {
		query = getSession().getNamedQuery(queryOrNamedQuery);
	} else {
		query = getSession().createQuery(queryOrNamedQuery);
	}
	
	setQueryValues(query, values);
	return query;
}
 

private <T> ReactiveQuery<T> buildReactiveQueryFromName(String name, Class<T> resultType) {
	checkOpen();
	try {
		pulseTransactionCoordinator();
		delayedAfterCompletion();

		// todo : apply stored setting at the JPA Query level too

		final NamedQueryDefinition namedQueryDefinition = getFactory().getNamedQueryRepository().getNamedQueryDefinition( name );
		if ( namedQueryDefinition != null ) {
			return createReactiveQuery( namedQueryDefinition, resultType );
		}

		final NamedSQLQueryDefinition nativeQueryDefinition = getFactory().getNamedQueryRepository().getNamedSQLQueryDefinition( name );
		if ( nativeQueryDefinition != null ) {
			return createReactiveNativeQuery( nativeQueryDefinition, resultType );
		}

		throw getExceptionConverter().convert( new IllegalArgumentException( "No query defined for that name [" + name + "]" ) );
	}
	catch (RuntimeException e) {
		throw !( e instanceof IllegalArgumentException ) ? new IllegalArgumentException( e ) : e;
	}
}
 

protected QueryImplementor createQuery(NamedQueryDefinition queryDefinition) {
		String queryString = queryDefinition.getQueryString();
		final QueryImpl query = new QueryImpl(
				this,
				getQueryPlan( queryString, false ).getParameterMetadata(),
				queryString
		);
		query.setHibernateFlushMode( queryDefinition.getFlushMode() );
		query.setComment( queryDefinition.getComment() != null ? queryDefinition.getComment() : queryDefinition.getName() );
		if ( queryDefinition.getLockOptions() != null ) {
			query.setLockOptions( queryDefinition.getLockOptions() );
		}

		initQueryFromNamedDefinition( query, queryDefinition );
//		applyQuerySettingsAndHints( query );

		return query;
	}
 

@Override
public QueryImplementor getNamedQuery(String name) {
	checkOpen();
	checkTransactionSynchStatus();
	delayedAfterCompletion();

	// look as HQL/JPQL first
	final NamedQueryDefinition queryDefinition = factory.getNamedQueryRepository().getNamedQueryDefinition( name );
	if ( queryDefinition != null ) {
		return createQuery( queryDefinition );
	}

	// then as a native query
	final NamedSQLQueryDefinition nativeQueryDefinition = factory.getNamedQueryRepository().getNamedSQLQueryDefinition( name );
	if ( nativeQueryDefinition != null ) {
		return createNativeQuery( nativeQueryDefinition, true );
	}

	throw exceptionConverter.convert( new IllegalArgumentException( "No query defined for that name [" + name + "]" ) );
}
 

public synchronized void registerNamedSQLQueryDefinition(String name, NamedSQLQueryDefinition definition) {
	if ( ! name.equals( definition.getName() ) ) {
		definition = definition.makeCopy( name );
	}

	final Map<String, NamedSQLQueryDefinition> copy = CollectionHelper.makeCopy( namedSqlQueryDefinitionMap );
	final NamedQueryDefinition previous = copy.put( name, definition );
	if ( previous != null ) {
		log.debugf(
				"registering named SQL query definition [%s] overriding previously registered definition [%s]",
				name,
				previous
		);
	}

	this.namedSqlQueryDefinitionMap = Collections.unmodifiableMap( copy );
}
 

public synchronized void registerNamedQueryDefinition(String name, NamedQueryDefinition definition) {
	if ( NamedSQLQueryDefinition.class.isInstance( definition ) ) {
		throw new IllegalArgumentException( "NamedSQLQueryDefinition instance incorrectly passed to registerNamedQueryDefinition" );
	}

	if ( ! name.equals( definition.getName() ) ) {
		definition = definition.makeCopy( name );
	}

	final Map<String, NamedQueryDefinition> copy = CollectionHelper.makeCopy( namedQueryDefinitionMap );
	final NamedQueryDefinition previous = copy.put( name, definition );
	if ( previous != null ) {
		log.debugf(
				"registering named query definition [%s] overriding previously registered definition [%s]",
				name,
				previous
		);
	}

	this.namedQueryDefinitionMap = Collections.unmodifiableMap( copy );
}
 

public NamedQueryRepository(
		Iterable<NamedQueryDefinition> namedQueryDefinitions,
		Iterable<NamedSQLQueryDefinition> namedSqlQueryDefinitions,
		Iterable<ResultSetMappingDefinition> namedSqlResultSetMappings,
		Map<String, ProcedureCallMemento> namedProcedureCalls) {
	final HashMap<String, NamedQueryDefinition> namedQueryDefinitionMap = new HashMap<String, NamedQueryDefinition>();
	for ( NamedQueryDefinition namedQueryDefinition : namedQueryDefinitions ) {
		namedQueryDefinitionMap.put( namedQueryDefinition.getName(), namedQueryDefinition );
	}
	this.namedQueryDefinitionMap = Collections.unmodifiableMap( namedQueryDefinitionMap );


	final HashMap<String, NamedSQLQueryDefinition> namedSqlQueryDefinitionMap = new HashMap<String, NamedSQLQueryDefinition>();
	for ( NamedSQLQueryDefinition namedSqlQueryDefinition : namedSqlQueryDefinitions ) {
		namedSqlQueryDefinitionMap.put( namedSqlQueryDefinition.getName(), namedSqlQueryDefinition );
	}
	this.namedSqlQueryDefinitionMap = Collections.unmodifiableMap( namedSqlQueryDefinitionMap );

	final HashMap<String, ResultSetMappingDefinition> namedSqlResultSetMappingMap = new HashMap<String, ResultSetMappingDefinition>();
	for ( ResultSetMappingDefinition resultSetMappingDefinition : namedSqlResultSetMappings ) {
		namedSqlResultSetMappingMap.put( resultSetMappingDefinition.getName(), resultSetMappingDefinition );
	}
	this.namedSqlResultSetMappingMap = Collections.unmodifiableMap( namedSqlResultSetMappingMap );
	this.procedureCallMementoMap = Collections.unmodifiableMap( namedProcedureCalls );
}
 

public static void bindQuery(
		NamedQuery queryAnn,
		MetadataBuildingContext context,
		boolean isDefault) {
	if ( queryAnn == null ) return;
	if ( BinderHelper.isEmptyAnnotationValue( queryAnn.name() ) ) {
		throw new AnnotationException( "A named query must have a name when used in class or package level" );
	}
	//EJBQL Query
	QueryHintDefinition hints = new QueryHintDefinition( queryAnn.hints() );
	String queryName = queryAnn.query();
	NamedQueryDefinition queryDefinition = new NamedQueryDefinitionBuilder( queryAnn.name() )
			.setLockOptions( hints.determineLockOptions( queryAnn ) )
			.setQuery( queryName )
			.setCacheable( hints.getBoolean( queryName, QueryHints.CACHEABLE ) )
			.setCacheRegion( hints.getString( queryName, QueryHints.CACHE_REGION ) )
			.setTimeout( hints.getTimeout( queryName ) )
			.setFetchSize( hints.getInteger( queryName, QueryHints.FETCH_SIZE ) )
			.setFlushMode( hints.getFlushMode( queryName ) )
			.setCacheMode( hints.getCacheMode( queryName ) )
			.setReadOnly( hints.getBoolean( queryName, QueryHints.READ_ONLY ) )
			.setComment( hints.getString( queryName, QueryHints.COMMENT ) )
			.setParameterTypes( null )
			.createNamedQueryDefinition();

	if ( isDefault ) {
		context.getMetadataCollector().addDefaultQuery( queryDefinition );
	}
	else {
		context.getMetadataCollector().addNamedQuery( queryDefinition );
	}

	if ( LOG.isDebugEnabled() ) {
		LOG.debugf( "Binding named query: %s => %s", queryDefinition.getName(), queryDefinition.getQueryString() );
	}
}
 

private <T> ReactiveQuery<T> createReactiveQuery(NamedQueryDefinition namedQueryDefinition, Class<T> resultType) {
	final ReactiveQuery<T> query = createReactiveQuery( namedQueryDefinition );
	if ( resultType != null ) {
		resultClassChecking( resultType, createQuery( namedQueryDefinition ) );
	}
	return query;
}
 

@Override
public void addNamedQuery(NamedQueryDefinition def) {
	if ( def == null ) {
		throw new IllegalArgumentException( "Named query definition is null" );
	}
	else if ( def.getName() == null ) {
		throw new IllegalArgumentException( "Named query definition name is null: " + def.getQueryString() );
	}

	if ( defaultNamedQueryNames.contains( def.getName() ) ) {
		return;
	}

	applyNamedQuery( def.getName(), def );
}
 

@SuppressWarnings({"WeakerAccess", "unchecked"})
protected <T> QueryImplementor<T> createQuery(NamedQueryDefinition namedQueryDefinition, Class<T> resultType) {
	final QueryImplementor query = createQuery( namedQueryDefinition );
	if ( resultType != null ) {
		resultClassChecking( resultType, query );
	}
	return query;
}
 

private <T> ReactiveQuery<T> createReactiveQuery(NamedQueryDefinition queryDefinition) {
	String queryString = queryDefinition.getQueryString();
	ParameterMetadataImpl paramMetadata = getQueryPlan( queryString, false ).getParameterMetadata();
	ReactiveQueryImpl<T> query = new ReactiveQueryImpl<>( this, paramMetadata, queryString, queryType( queryString ) );
	applyQuerySettingsAndHints( query );
	query.setHibernateFlushMode( queryDefinition.getFlushMode() );
	query.setComment( queryDefinition.getComment() != null ? queryDefinition.getComment() : queryDefinition.getName() );
	if ( queryDefinition.getLockOptions() != null ) {
		query.setLockOptions( queryDefinition.getLockOptions() );
	}

	initQueryFromNamedDefinition( query, queryDefinition );

	return query;
}
 

protected void initQueryFromNamedDefinition(Query query, NamedQueryDefinition nqd) {
	// todo : cacheable and readonly should be Boolean rather than boolean...
	query.setCacheable( nqd.isCacheable() );
	query.setCacheRegion( nqd.getCacheRegion() );
	query.setReadOnly( nqd.isReadOnly() );

	if ( nqd.getTimeout() != null ) {
		query.setTimeout( nqd.getTimeout() );
	}
	if ( nqd.getFetchSize() != null ) {
		query.setFetchSize( nqd.getFetchSize() );
	}
	if ( nqd.getCacheMode() != null ) {
		query.setCacheMode( nqd.getCacheMode() );
	}
	if ( nqd.getComment() != null ) {
		query.setComment( nqd.getComment() );
	}
	if ( nqd.getFirstResult() != null ) {
		query.setFirstResult( nqd.getFirstResult() );
	}
	if ( nqd.getMaxResults() != null ) {
		query.setMaxResults( nqd.getMaxResults() );
	}
	if ( nqd.getFlushMode() != null ) {
		query.setHibernateFlushMode( nqd.getFlushMode() );
	}
}
 

private NamedQueryDefinition extractHqlQueryDefinition(org.hibernate.query.Query hqlQuery, String name) {
	final NamedQueryDefinitionBuilder builder = new NamedQueryDefinitionBuilder( name );
	fillInNamedQueryBuilder( builder, hqlQuery );
	// LockOptions only valid for HQL/JPQL queries...
	builder.setLockOptions( hqlQuery.getLockOptions().makeCopy() );
	return builder.createNamedQueryDefinition();
}
 

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

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

	FlushMode flushMode;
	flushMode = getFlushMode( queryAnn.flushMode() );

	NamedQueryDefinition query = new NamedQueryDefinitionBuilder().setName( queryAnn.name() )
			.setQuery( queryAnn.query() )
			.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( flushMode )
			.setCacheMode( getCacheMode( queryAnn.cacheMode() ) )
			.setReadOnly( queryAnn.readOnly() )
			.setComment( BinderHelper.isEmptyAnnotationValue( queryAnn.comment() ) ? null : queryAnn.comment() )
			.setParameterTypes( null )
			.createNamedQueryDefinition();

	context.getMetadataCollector().addNamedQuery( query );
	if ( LOG.isDebugEnabled() ) {
		LOG.debugf( "Binding named query: %s => %s", query.getName(), query.getQueryString() );
	}
}
 

protected void reset() {
	implicitNamingStrategy = ImplicitNamingStrategyJpaCompliantImpl.INSTANCE;
	physicalNamingStrategy = PhysicalNamingStrategyStandardImpl.INSTANCE;
	namedQueries = new HashMap<String,NamedQueryDefinition>();
	namedSqlQueries = new HashMap<String,NamedSQLQueryDefinition>();
	sqlResultSetMappings = new HashMap<String, ResultSetMappingDefinition>();
	namedEntityGraphMap = new HashMap<String, NamedEntityGraphDefinition>();
	namedProcedureCallMap = new HashMap<String, NamedProcedureCallDefinition>(  );

	standardServiceRegistryBuilder = new StandardServiceRegistryBuilder( bootstrapServiceRegistry );
	entityTuplizerFactory = new EntityTuplizerFactory();
	interceptor = EmptyInterceptor.INSTANCE;
	properties = new Properties(  );
	properties.putAll( standardServiceRegistryBuilder.getSettings());
}
 

public NamedQueryRepository(
		Map<String,NamedQueryDefinition> namedQueryDefinitionMap,
		Map<String,NamedSQLQueryDefinition> namedSqlQueryDefinitionMap,
		Map<String,ResultSetMappingDefinition> namedSqlResultSetMappingMap,
		Map<String, ProcedureCallMemento> namedProcedureCallMap) {
	this.namedQueryDefinitionMap = Collections.unmodifiableMap( namedQueryDefinitionMap );
	this.namedSqlQueryDefinitionMap = Collections.unmodifiableMap( namedSqlQueryDefinitionMap );
	this.namedSqlResultSetMappingMap = Collections.unmodifiableMap( namedSqlResultSetMappingMap );
	this.procedureCallMementoMap = Collections.unmodifiableMap( namedProcedureCallMap );
}
 

@Override
public Collection<NamedQueryDefinition> getNamedQueryDefinitions() {
	return delegate.getNamedQueryDefinitions();
}
 

public void registerNamedQueryDefinition(String name,
        NamedQueryDefinition definition) {
    sessionFactoryImplementor
            .registerNamedQueryDefinition(name, definition);
}
 

public NamedQueryDefinition getNamedQuery(String queryName) {
    return sessionFactoryImplementor.getNamedQuery(queryName);
}
 

@Override
public java.util.Collection<NamedQueryDefinition> getNamedQueryDefinitions() {
	return namedQueryMap.values();
}
 

@Override
public NamedQueryDefinition getNamedQueryDefinition(String name) {
	return namedQueryMap.get( name );
}
 

MetadataImpl(
		UUID uuid,
		MetadataBuildingOptions metadataBuildingOptions,
		MutableIdentifierGeneratorFactory identifierGeneratorFactory,
		Map<String, PersistentClass> entityBindingMap,
		Map<Class, MappedSuperclass> mappedSuperclassMap,
		Map<String, Collection> collectionBindingMap,
		Map<String, TypeDefinition> typeDefinitionMap,
		Map<String, FilterDefinition> filterDefinitionMap,
		Map<String, FetchProfile> fetchProfileMap,
		Map<String, String> imports,
		Map<String, IdentifierGeneratorDefinition> idGeneratorDefinitionMap,
		Map<String, NamedQueryDefinition> namedQueryMap,
		Map<String, NamedSQLQueryDefinition> namedNativeQueryMap,
		Map<String, NamedProcedureCallDefinition> namedProcedureCallMap,
		Map<String, ResultSetMappingDefinition> sqlResultSetMappingMap,
		Map<String, NamedEntityGraphDefinition> namedEntityGraphMap,
		Map<String, SQLFunction> sqlFunctionMap,
		java.util.Collection<DomainDataRegionConfigImpl.Builder> cacheRegionConfigBuilders,
		Database database,
		BootstrapContext bootstrapContext) {
	this.uuid = uuid;
	this.metadataBuildingOptions = metadataBuildingOptions;
	this.identifierGeneratorFactory = identifierGeneratorFactory;
	this.entityBindingMap = entityBindingMap;
	this.mappedSuperclassMap = mappedSuperclassMap;
	this.collectionBindingMap = collectionBindingMap;
	this.typeDefinitionMap = typeDefinitionMap;
	this.filterDefinitionMap = filterDefinitionMap;
	this.fetchProfileMap = fetchProfileMap;
	this.imports = imports;
	this.idGeneratorDefinitionMap = idGeneratorDefinitionMap;
	this.namedQueryMap = namedQueryMap;
	this.namedNativeQueryMap = namedNativeQueryMap;
	this.namedProcedureCallMap = namedProcedureCallMap;
	this.sqlResultSetMappingMap = sqlResultSetMappingMap;
	this.namedEntityGraphMap = namedEntityGraphMap;
	this.sqlFunctionMap = sqlFunctionMap;
	this.cacheRegionConfigBuilders = cacheRegionConfigBuilders;
	this.database = database;
	this.bootstrapContext = bootstrapContext;
}
 

@Override
public void addDefaultQuery(NamedQueryDefinition queryDefinition) {
	applyNamedQuery( queryDefinition.getName(), queryDefinition );
	defaultNamedQueryNames.add( queryDefinition.getName() );
}
 

private void applyNamedQuery(String name, NamedQueryDefinition query) {
	checkQueryName( name );
	namedQueryMap.put( name.intern(), query );
}
 

@Override
public java.util.Collection<NamedQueryDefinition> getNamedQueryDefinitions() {
	return namedQueryMap.values();
}
 

public NamedQueryDefinition getNamedQueryDefinition(String name) {
	if ( name == null ) {
		throw new IllegalArgumentException( "null is not a valid query name" );
	}
	return namedQueryMap.get( name );
}
 

@Override
protected void initQueryFromNamedDefinition(Query query, NamedQueryDefinition namedQueryDefinition) {
	super.initQueryFromNamedDefinition( query, namedQueryDefinition );

	if ( namedQueryDefinition.isCacheable() ) {
		query.setHint( QueryHints.HINT_CACHEABLE, true );
		if ( namedQueryDefinition.getCacheRegion() != null ) {
			query.setHint( QueryHints.HINT_CACHE_REGION, namedQueryDefinition.getCacheRegion() );
		}
	}

	if ( namedQueryDefinition.getCacheMode() != null ) {
		query.setHint( QueryHints.HINT_CACHE_MODE, namedQueryDefinition.getCacheMode() );
	}

	if ( namedQueryDefinition.isReadOnly() ) {
		query.setHint( QueryHints.HINT_READONLY, true );
	}

	if ( namedQueryDefinition.getTimeout() != null ) {
		query.setHint( QueryHints.SPEC_HINT_TIMEOUT, namedQueryDefinition.getTimeout() * 1000 );
	}

	if ( namedQueryDefinition.getFetchSize() != null ) {
		query.setHint( QueryHints.HINT_FETCH_SIZE, namedQueryDefinition.getFetchSize() );
	}

	if ( namedQueryDefinition.getComment() != null ) {
		query.setHint( QueryHints.HINT_COMMENT, namedQueryDefinition.getComment() );
	}

	if ( namedQueryDefinition.getFirstResult() != null ) {
		query.setFirstResult( namedQueryDefinition.getFirstResult() );
	}

	if ( namedQueryDefinition.getMaxResults() != null ) {
		query.setMaxResults( namedQueryDefinition.getMaxResults() );
	}

	if ( namedQueryDefinition.getLockOptions() != null ) {
		if ( namedQueryDefinition.getLockOptions().getLockMode() != null ) {
			query.setLockMode(
					LockModeTypeHelper.getLockModeType( namedQueryDefinition.getLockOptions().getLockMode() )
			);
		}
	}

	if ( namedQueryDefinition.getFlushMode() != null ) {
		query.setHibernateFlushMode( namedQueryDefinition.getFlushMode() );
	}
}
 

@Override
public NamedQueryDefinition getNamedQueryDefinition(String name) {
	return delegate.getNamedQueryDefinition( name );
}