org.hibernate.engine.spi.NamedSQLQueryDefinition Java Examples

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

/**
 * 根据查询SQL与参数列表创建SQLQuery对象
 * 
 * @param queryOrNamedSQLQuery query 或者 NamedSQLQuery
 * @param values 数量可变的参数,按顺序绑定.
 *            
 * @return {@link SQLQuery}
 */
protected SQLQuery createSQLQuery( String queryOrNamedSQLQuery,  Object... values) {
	Assert.hasText(queryOrNamedSQLQuery, "queryOrNamedSQLQuery不能为空");
	SessionFactoryImpl factory = (SessionFactoryImpl) sessionFactory;
	NamedSQLQueryDefinition nsqlqd = factory.getNamedSQLQuery( queryOrNamedSQLQuery );
	Query query = null;
	
	if (nsqlqd != null) {
		query = getSession().getNamedQuery(queryOrNamedSQLQuery);
	} else {
		query = getSession().createSQLQuery(queryOrNamedSQLQuery);
	}
	
	setQueryValues(query, values);
	SQLQuery sqlQuery = (SQLQuery)query;
	
	return sqlQuery.addEntity(entityClass);
}
 

@SuppressWarnings({"WeakerAccess", "unchecked"})
protected <T> NativeQueryImplementor createNativeQuery(NamedSQLQueryDefinition queryDefinition, Class<T> resultType) {
	if ( resultType != null && !Tuple.class.equals(resultType)) {
		resultClassChecking( resultType, queryDefinition );
	}

	final NativeQueryImpl query = new NativeQueryImpl(
			queryDefinition,
			this,
			factory.getQueryPlanCache().getSQLParameterMetadata( queryDefinition.getQueryString(), false )
	);
	if (Tuple.class.equals(resultType)) {
		query.setResultTransformer(new NativeQueryTupleTransformer());
	}
	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;
}
 

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

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

private <T> ReactiveNativeQuery<T> createReactiveNativeQuery(NamedSQLQueryDefinition queryDefinition, Class<T> resultType) {
	if ( resultType != null && !Tuple.class.equals( resultType ) && !Object[].class.equals( resultType ) ) {
		resultClassChecking( resultType, queryDefinition );
	}

	final ReactiveNativeQueryImpl<T> query = new ReactiveNativeQueryImpl<>(
			queryDefinition,
			this,
			getFactory().getQueryPlanCache().getSQLParameterMetadata( queryDefinition.getQueryString(), false )
	);
	if ( Tuple.class.equals( resultType ) ) {
		query.setResultTransformer( new NativeQueryTupleTransformer() );
	}
	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;
}
 

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

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

/**
 * Constructs a NativeQueryImpl given a sql query defined in the mappings.
 *
 * @param queryDef The representation of the defined <sql-query/>.
 * @param session The session to which this NativeQuery belongs.
 * @param parameterMetadata Metadata about parameters found in the query.
 */
public NativeQueryImpl(
		NamedSQLQueryDefinition queryDef,
		SharedSessionContractImplementor session,
		ParameterMetadata parameterMetadata) {
	super( session, parameterMetadata );

	this.sqlString = queryDef.getQueryString();
	this.callable = queryDef.isCallable();
	this.querySpaces = queryDef.getQuerySpaces() == null ? null : new ArrayList<>( queryDef.getQuerySpaces() );

	if ( queryDef.getResultSetRef() != null ) {
		ResultSetMappingDefinition definition = session.getFactory()
				.getNamedQueryRepository()
				.getResultSetMappingDefinition( queryDef.getResultSetRef() );
		if ( definition == null ) {
			throw new MappingException(
					"Unable to find resultset-ref definition: " +
							queryDef.getResultSetRef()
			);
		}
		this.queryReturns = new ArrayList<>( Arrays.asList( definition.getQueryReturns() ) );
	}
	else if ( queryDef.getQueryReturns() != null && queryDef.getQueryReturns().length > 0 ) {
		this.queryReturns = new ArrayList<>( Arrays.asList( queryDef.getQueryReturns() ) );
	}
	else {
		this.queryReturns = new ArrayList<>();
	}


	this.queryParameterBindings = QueryParameterBindingsImpl.from(
			parameterMetadata,
			session.getFactory(),
			session.isQueryParametersValidationEnabled()
	);
}
 

private NamedSQLQueryDefinition extractSqlQueryDefinition(org.hibernate.query.NativeQuery nativeSqlQuery, String name) {
	final NamedSQLQueryDefinitionBuilder builder = new NamedSQLQueryDefinitionBuilder( name );
	fillInNamedQueryBuilder( builder, nativeSqlQuery );
	builder.setCallable( nativeSqlQuery.isCallable() )
			.setQuerySpaces( nativeSqlQuery.getSynchronizedQuerySpaces() )
			.setQueryReturns( nativeSqlQuery.getQueryReturns() );
	return builder.createNamedQueryDefinition();
}
 

private NativeQueryImplementor createNativeQuery(NamedSQLQueryDefinition queryDefinition, boolean isOrdinalParameterZeroBased) {
	final ParameterMetadata parameterMetadata = factory.getQueryPlanCache().getSQLParameterMetadata(
			queryDefinition.getQueryString(),
			isOrdinalParameterZeroBased
	);
	return getNativeQueryImplementor( queryDefinition, parameterMetadata );
}
 

private NativeQueryImplementor getNativeQueryImplementor(
		NamedSQLQueryDefinition queryDefinition,
		ParameterMetadata parameterMetadata) {
	final NativeQueryImpl query = new NativeQueryImpl(
			queryDefinition,
			this,
			parameterMetadata
	);
	query.setComment( queryDefinition.getComment() != null ? queryDefinition.getComment() : queryDefinition.getName() );

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

	return query;
}
 

@Override
public void addNamedNativeQuery(NamedSQLQueryDefinition def) {
	if ( def == null ) {
		throw new IllegalArgumentException( "Named native query definition object is null" );
	}
	if ( def.getName() == null ) {
		throw new IllegalArgumentException( "Named native query definition name is null: " + def.getQueryString() );
	}

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

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

@Override
public NativeQueryImplementor getNamedNativeQuery(String name) {
	checkOpen();
	checkTransactionSynchStatus();
	delayedAfterCompletion();

	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 + "]" ) );
}
 

@Override
public NamedSQLQueryDefinition getNamedNativeQueryDefinition(String name) {
	return namedNativeQueryMap.get( name );
}
 

public ReactiveNativeQueryImpl(
		NamedSQLQueryDefinition queryDef,
		SharedSessionContractImplementor session,
		ParameterMetadata parameterMetadata) {
	super(queryDef, session, parameterMetadata);
}
 

@Override
public java.util.Collection<NamedSQLQueryDefinition> getNamedNativeQueryDefinitions() {
	return namedNativeQueryMap.values();
}
 

private void applyNamedNativeQuery(String name, NamedSQLQueryDefinition query) {
	checkQueryName( name );
	namedNativeQueryMap.put( name.intern(), query );
}
 

@Override
public void addDefaultNamedNativeQuery(NamedSQLQueryDefinition query) {
	applyNamedNativeQuery( query.getName(), query );
	defaultNamedNativeQueryNames.add( query.getName() );
}
 

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 NamedSQLQueryDefinition getNamedNativeQueryDefinition(String name) {
	return namedNativeQueryMap.get( name );
}
 

@Override
public java.util.Collection<NamedSQLQueryDefinition> getNamedNativeQueryDefinitions() {
	return namedNativeQueryMap.values();
}
 

public NamedSQLQueryDefinition getNamedSQLQuery(String queryName) {
    return sessionFactoryImplementor.getNamedSQLQuery(queryName);
}
 

public void registerNamedSQLQueryDefinition(String name,
        NamedSQLQueryDefinition definition) {
    sessionFactoryImplementor.registerNamedSQLQueryDefinition(name,
            definition);
}
 

public static void processNamedNativeQuery(
		final HbmLocalMetadataBuildingContext context,
		JaxbHbmNamedNativeQueryType namedQueryBinding,
		String prefix) {
	final String queryName = prefix + namedQueryBinding.getName();
	final NamedSQLQueryDefinitionBuilder builder = new NamedSQLQueryDefinitionBuilder()
			.setName( queryName )
			.setComment( namedQueryBinding.getComment() )
			.setCacheable( namedQueryBinding.isCacheable() )
			.setCacheMode( namedQueryBinding.getCacheMode() )
			.setCacheRegion( namedQueryBinding.getCacheRegion() )
			.setTimeout( namedQueryBinding.getTimeout() )
			.setReadOnly( namedQueryBinding.isReadOnly() )
			.setFlushMode( namedQueryBinding.getFlushMode() )
			.setFetchSize( namedQueryBinding.getFetchSize() )
			.setCallable( namedQueryBinding.isCallable() )
			.setResultSetRef( namedQueryBinding.getResultsetRef() );

	final ImplicitResultSetMappingDefinition.Builder implicitResultSetMappingBuilder
			= new ImplicitResultSetMappingDefinition.Builder( queryName );

	boolean foundQuery = false;

	for ( Object content : namedQueryBinding.getContent() ) {
		final boolean wasQuery = processNamedQueryContentItem(
				content,
				builder,
				implicitResultSetMappingBuilder,
				namedQueryBinding,
				context
		);
		if ( wasQuery ) {
			foundQuery = true;
		}
	}

	if ( !foundQuery ) {
		throw new org.hibernate.boot.MappingException(
				String.format(
						"Named native query [%s] did not specify query string",
						namedQueryBinding.getName()
				),
				context.getOrigin()
		);
	}

	if ( implicitResultSetMappingBuilder.hasAnyReturns() ) {
		if ( StringHelper.isNotEmpty( namedQueryBinding.getResultsetRef() ) ) {
			throw new org.hibernate.boot.MappingException(
					String.format(
							"Named native query [%s] specified both a resultset-ref and an inline mapping of results",
							namedQueryBinding.getName()
					),
					context.getOrigin()
			);
		}

		// Building a ResultSet mapping needs access to entity bindings for any entity
		// returns it defines.  But binding for those entities may have not been
		// completed yet.  For "normal" ResultSet mappings, this is already handled by
		// the fact that MetadataSourceProcessor#processResultSetMappings() is called
		// after all entity hierarchies have been processed.  However, here we are in
		// the middle of processing named-queries (either top-level or entity-level)
		// and have no guarantee that any entity bindings we may need here are bound.
		// So we add the second-pass to bind the implicit resultSet mapping.
		//
		// It is possible to know here whether the second-pass is needed or whether we
		// can immediately bind the ResultSet mapping.
		// todo : consider implementing this (^^) checking

		final ImplicitResultSetMappingDefinition implicitResultSetMappingDefinition = implicitResultSetMappingBuilder.build();
		builder.setResultSetRef( implicitResultSetMappingDefinition.getName() );
		context.getMetadataCollector().addSecondPass(
				new SecondPass() {
					@Override
					public void doSecondPass(Map persistentClasses) throws MappingException {
						final ResultSetMappingDefinition resultSetMappingDefinition =
								ResultSetMappingBinder.bind( implicitResultSetMappingDefinition, context );
						context.getMetadataCollector().addResultSetMapping( resultSetMappingDefinition );
						NativeSQLQueryReturn[] newQueryReturns = resultSetMappingDefinition.getQueryReturns();
						final NamedSQLQueryDefinition queryDefinition =
								context.getMetadataCollector().getNamedNativeQueryDefinition( queryName );
						if ( queryDefinition != null ) {
							queryDefinition.addQueryReturns( newQueryReturns );
						}
					}
				}
		);
	}

	context.getMetadataCollector().addNamedNativeQuery( builder.createNamedQueryDefinition() );
}
 

@Override
public Collection<NamedSQLQueryDefinition> getNamedNativeQueryDefinitions() {
	return delegate.getNamedNativeQueryDefinitions();
}
 

@Override
public NamedSQLQueryDefinition getNamedNativeQueryDefinition(String name) {
	return delegate.getNamedNativeQueryDefinition( name );
}