@Override
public CompletionStage<Integer> executeReactiveUpdate(NativeSQLQuerySpecification specification,
													  QueryParameters parameters) {
	checkOpenOrWaitingForAutoClose();
	pulseTransactionCoordinator();
	parameters.validateParameters();

	ReactiveNativeSQLQueryPlan reactivePlan = //getNativeQueryPlan( specification );
			new ReactiveNativeSQLQueryPlan(
					specification.getQueryString(),
					new SQLCustomQuery(
							specification.getQueryString(),
							specification.getQueryReturns(),
							specification.getQuerySpaces(),
							getFactory()
					) );
	return reactiveAutoFlushIfRequired( reactivePlan.getCustomQuery().getQuerySpaces() )
			.thenCompose( v -> reactivePlan.performExecuteReactiveUpdate( parameters, this ) )
			.whenComplete( (count, x) -> {
				afterOperation( x == null );
				delayedAfterCompletion();
			} );
}
 

@Override
public int executeNativeUpdate(
		NativeSQLQuerySpecification nativeQuerySpecification,
		QueryParameters queryParameters) throws HibernateException {
	checkOpenOrWaitingForAutoClose();
	checkTransactionSynchStatus();
	queryParameters.validateParameters();
	NativeSQLQueryPlan plan = getNativeQueryPlan( nativeQuerySpecification );


	autoFlushIfRequired( plan.getCustomQuery().getQuerySpaces() );

	boolean success = false;
	int result = 0;
	try {
		result = plan.performExecuteUpdate( queryParameters, this );
		success = true;
	}
	finally {
		afterOperation( success );
		delayedAfterCompletion();
	}
	return result;
}
 

@Override
public int executeNativeUpdate(
		NativeSQLQuerySpecification nativeSQLQuerySpecification,
		QueryParameters queryParameters) throws HibernateException {
	checkOpen();
	queryParameters.validateParameters();
	NativeSQLQueryPlan plan = getNativeQueryPlan( nativeSQLQuerySpecification );

	boolean success = false;
	int result = 0;
	try {
		result = plan.performExecuteUpdate( queryParameters, this );
		success = true;
	}
	finally {
		afterOperation( success );
	}
	temporaryPersistenceContext.clear();
	return result;
}
 

private NativeSQLQuerySpecification generateQuerySpecification() {
	return new NativeSQLQuerySpecification(
			getQueryParameterBindings().expandListValuedParameters( getQueryString(), getProducer() ),
			getQueryReturns().toArray( new NativeSQLQueryReturn[0] ),
			getSynchronizedQuerySpaces()
	);
}
 

private NativeSQLQuerySpecification generateQuerySpecification() {
	return new NativeSQLQuerySpecification(
			getQueryParameterBindings().expandListValuedParameters( getQueryString(), getProducer() ),
			queryReturns.toArray( new NativeSQLQueryReturn[queryReturns.size()] ),
			querySpaces
	);
}
 

@Override
protected ScrollableResultsImplementor doScroll(ScrollMode scrollMode) {
	final NativeSQLQuerySpecification nativeSQLQuerySpecification = generateQuerySpecification();
	final QueryParameters queryParameters = getQueryParameters();
	queryParameters.setScrollMode( scrollMode );
	return getProducer().scroll(
			nativeSQLQuerySpecification,
			queryParameters
	);
}
 

/**
 * Get the query plan for a native SQL query, creating it and caching it if not already cached
 *
 * @param spec The native SQL query specification
 *
 * @return The query plan
 *
 * @throws QueryException Indicates a problem translating the query
 * @throws MappingException Indicates a problem translating the query
 */
@SuppressWarnings("unchecked")
public NativeSQLQueryPlan getNativeSQLQueryPlan(final NativeSQLQuerySpecification spec) {
	NativeSQLQueryPlan value = (NativeSQLQueryPlan) queryPlanCache.get( spec );
	if ( value == null ) {
		LOG.tracev( "Unable to locate native-sql query plan in cache; generating ({0})", spec.getQueryString() );
		value = nativeQueryInterpreter.createQueryPlan( spec, factory );
		queryPlanCache.putIfAbsent( spec, value );
	}
	else {
		LOG.tracev( "Located native-sql query plan in cache ({0})", spec.getQueryString() );
	}
	return value;
}
 

@Override
public NativeSQLQueryPlan createQueryPlan(
		NativeSQLQuerySpecification specification,
		SessionFactoryImplementor sessionFactory) {
	CustomQuery customQuery = new SQLCustomQuery(
			specification.getQueryString(),
			specification.getQueryReturns(),
			specification.getQuerySpaces(),
			sessionFactory
	);

	return new NativeSQLQueryPlan( specification.getQueryString(), customQuery );
}
 

CompletionStage<Integer> executeReactiveUpdate(NativeSQLQuerySpecification specification,
QueryParameters parameters);
 

@Override
public <T> CompletionStage<List<T>> reactiveList(NativeSQLQuerySpecification spec, QueryParameters parameters) {
	return listReactiveCustomQuery( getNativeQueryPlan( spec ).getCustomQuery(), parameters)
			//TODO: this typecast is rubbish
			.thenApply( list -> (List<T>) list );
}
 

@Override
public List list(NativeSQLQuerySpecification spec, QueryParameters queryParameters) throws HibernateException {
	return delegate.list( spec, queryParameters );
}
 

@Override
public ScrollableResultsImplementor scroll(NativeSQLQuerySpecification spec, QueryParameters queryParameters) throws HibernateException {
	return delegate.scroll( spec, queryParameters );
}
 

@Override
public int executeNativeUpdate(NativeSQLQuerySpecification specification, QueryParameters queryParameters) throws HibernateException {
	return delegate.executeNativeUpdate( specification, queryParameters );
}
 

protected NativeSQLQueryPlan getNativeQueryPlan(NativeSQLQuerySpecification spec) throws HibernateException {
	return getFactory().getQueryPlanCache().getNativeSQLQueryPlan( spec );
}
 

@Override
public List list(NativeSQLQuerySpecification spec, QueryParameters queryParameters) {
	return listCustomQuery( getNativeQueryPlan( spec ).getCustomQuery(), queryParameters );
}
 

@Override
public ScrollableResultsImplementor scroll(NativeSQLQuerySpecification spec, QueryParameters queryParameters) {
	return scrollCustomQuery( getNativeQueryPlan( spec ).getCustomQuery(), queryParameters );
}
 

@SuppressWarnings("rawtypes")
@Override
public List list(NativeSQLQuerySpecification spec, QueryParameters queryParameters) throws HibernateException {
	return target.list(spec, queryParameters);
}
 

@Override
public ScrollableResultsImplementor scroll(NativeSQLQuerySpecification spec, QueryParameters queryParameters) {
	return target.scroll(spec, queryParameters);
}
 

@Override
public int executeNativeUpdate(NativeSQLQuerySpecification specification, QueryParameters queryParameters)
		throws HibernateException {
	return target.executeNativeUpdate(specification, queryParameters);
}
 

/**
 * Creates a new query plan for the specified native query.
 *
 * @param specification Describes the query to create a plan for
 * @param sessionFactory The current session factory
 *
 * @return A query plan for the specified native query.
 */
NativeSQLQueryPlan createQueryPlan(NativeSQLQuerySpecification specification, SessionFactoryImplementor sessionFactory);
 

/**
 * Execute a native SQL query, and return the results as a fully built list.
 *
 * @param spec The specification of the native SQL query to execute.
 * @param queryParameters The parameters by which to perform the execution.
 *
 * @return The result list.
 *
 * @throws HibernateException
 */
List list(NativeSQLQuerySpecification spec, QueryParameters queryParameters)
		throws HibernateException;
 

/**
 * Execute a native SQL query, and return the results as a scrollable result.
 *
 * @param spec The specification of the native SQL query to execute.
 * @param queryParameters The parameters by which to perform the execution.
 *
 * @return The resulting scrollable result.
 *
 * @throws HibernateException
 */
ScrollableResultsImplementor scroll(NativeSQLQuerySpecification spec, QueryParameters queryParameters);
 

/**
 * Execute a native SQL update or delete query
 */
int executeNativeUpdate(NativeSQLQuerySpecification specification, QueryParameters queryParameters)
		throws HibernateException;
 

<T> CompletionStage<List<T>> reactiveList(NativeSQLQuerySpecification spec, QueryParameters parameters);